ContentObjectRenderer.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Frontend\ContentObject;

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\StringUtility;
use TYPO3\CMS\Core\Versioning\VersionState;
use TYPO3\CMS\Frontend\Imaging\GifBuilder;

class ContentObjectRenderer {

    public $align = array(
        'center',
        'right',
        'left'
    );

    public $stdWrapOrder = array(
        'stdWrapPreProcess' => 'hook',
        // this is a placeholder for the first Hook
        'cacheRead' => 'hook',
        // this is a placeholder for checking if the content is available in cache
        'setContentToCurrent' => 'boolean',
        'setContentToCurrent.' => 'array',
        'addPageCacheTags' => 'string',
        'addPageCacheTags.' => 'array',
        'setCurrent' => 'string',
        'setCurrent.' => 'array',
        'lang.' => 'array',
        'data' => 'getText',
        'data.' => 'array',
        'field' => 'fieldName',
        'field.' => 'array',
        'current' => 'boolean',
        'current.' => 'array',
        'cObject' => 'cObject',
        'cObject.' => 'array',
        'numRows.' => 'array',
        'filelist' => 'dir',
        'filelist.' => 'array',
        'preUserFunc' => 'functionName',
        'stdWrapOverride' => 'hook',
        // this is a placeholder for the second Hook
        'override' => 'string',
        'override.' => 'array',
        'preIfEmptyListNum' => 'listNum',
        'preIfEmptyListNum.' => 'array',
        'ifNull' => 'string',
        'ifNull.' => 'array',
        'ifEmpty' => 'string',
        'ifEmpty.' => 'array',
        'ifBlank' => 'string',
        'ifBlank.' => 'array',
        'listNum' => 'listNum',
        'listNum.' => 'array',
        'trim' => 'boolean',
        'trim.' => 'array',
        'strPad.' => 'array',
        'stdWrap' => 'stdWrap',
        'stdWrap.' => 'array',
        'stdWrapProcess' => 'hook',
        // this is a placeholder for the third Hook
        'required' => 'boolean',
        'required.' => 'array',
        'if.' => 'array',
        'fieldRequired' => 'fieldName',
        'fieldRequired.' => 'array',
        'csConv' => 'string',
        'csConv.' => 'array',
        'parseFunc' => 'objectpath',
        'parseFunc.' => 'array',
        'HTMLparser' => 'boolean',
        'HTMLparser.' => 'array',
        'split.' => 'array',
        'replacement.' => 'array',
        'prioriCalc' => 'boolean',
        'prioriCalc.' => 'array',
        'char' => 'integer',
        'char.' => 'array',
        'intval' => 'boolean',
        'intval.' => 'array',
        'hash' => 'string',
        'hash.' => 'array',
        'round' => 'boolean',
        'round.' => 'array',
        'numberFormat.' => 'array',
        'expandList' => 'boolean',
        'expandList.' => 'array',
        'date' => 'dateconf',
        'date.' => 'array',
        'strftime' => 'strftimeconf',
        'strftime.' => 'array',
        'age' => 'boolean',
        'age.' => 'array',
        'case' => 'case',
        'case.' => 'array',
        'bytes' => 'boolean',
        'bytes.' => 'array',
        'substring' => 'parameters',
        'substring.' => 'array',
        'removeBadHTML' => 'boolean',
        'removeBadHTML.' => 'array',
        'cropHTML' => 'crop',
        'cropHTML.' => 'array',
        'stripHtml' => 'boolean',
        'stripHtml.' => 'array',
        'crop' => 'crop',
        'crop.' => 'array',
        'rawUrlEncode' => 'boolean',
        'rawUrlEncode.' => 'array',
        'htmlSpecialChars' => 'boolean',
        'htmlSpecialChars.' => 'array',
        'encodeForJavaScriptValue' => 'boolean',
        'encodeForJavaScriptValue.' => 'array',
        'doubleBrTag' => 'string',
        'doubleBrTag.' => 'array',
        'br' => 'boolean',
        'br.' => 'array',
        'brTag' => 'string',
        'brTag.' => 'array',
        'encapsLines.' => 'array',
        'keywords' => 'boolean',
        'keywords.' => 'array',
        'innerWrap' => 'wrap',
        'innerWrap.' => 'array',
        'innerWrap2' => 'wrap',
        'innerWrap2.' => 'array',
        'fontTag' => 'wrap',
        'fontTag.' => 'array',
        'addParams.' => 'array',
        'textStyle.' => 'array',
        'tableStyle.' => 'array',
        'filelink.' => 'array',
        'preCObject' => 'cObject',
        'preCObject.' => 'array',
        'postCObject' => 'cObject',
        'postCObject.' => 'array',
        'wrapAlign' => 'align',
        'wrapAlign.' => 'array',
        'typolink.' => 'array',
        'TCAselectItem.' => 'array',
        'space' => 'space',
        'space.' => 'array',
        'spaceBefore' => 'int',
        'spaceBefore.' => 'array',
        'spaceAfter' => 'int',
        'spaceAfter.' => 'array',
        'wrap' => 'wrap',
        'wrap.' => 'array',
        'noTrimWrap' => 'wrap',
        'noTrimWrap.' => 'array',
        'wrap2' => 'wrap',
        'wrap2.' => 'array',
        'dataWrap' => 'dataWrap',
        'dataWrap.' => 'array',
        'prepend' => 'cObject',
        'prepend.' => 'array',
        'append' => 'cObject',
        'append.' => 'array',
        'wrap3' => 'wrap',
        'wrap3.' => 'array',
        'orderedStdWrap' => 'stdWrap',
        'orderedStdWrap.' => 'array',
        'outerWrap' => 'wrap',
        'outerWrap.' => 'array',
        'insertData' => 'boolean',
        'insertData.' => 'array',
        'offsetWrap' => 'space',
        'offsetWrap.' => 'array',
        'postUserFunc' => 'functionName',
        'postUserFuncInt' => 'functionName',
        'prefixComment' => 'string',
        'prefixComment.' => 'array',
        'editIcons' => 'string',
        'editIcons.' => 'array',
        'editPanel' => 'boolean',
        'editPanel.' => 'array',
        'cacheStore' => 'hook',
        // this is a placeholder for storing the content in cache
        'stdWrapPostProcess' => 'hook',
        // this is a placeholder for the last Hook
        'debug' => 'boolean',
        'debug.' => 'array',
        'debugFunc' => 'boolean',
        'debugFunc.' => 'array',
        'debugData' => 'boolean',
        'debugData.' => 'array'
    );

    protected $contentObjectClassMapping = array(
        'TEXT' => 'Text',
        'CASE' => 'Case',
        'CLEARGIF' => 'ClearGif',
        'COBJ_ARRAY' => 'ContentObjectArray',
        'COA' => 'ContentObjectArray',
        'COA_INT' => 'ContentObjectArrayInternal',
        'USER' => 'User',
        'USER_INT' => 'UserInternal',
        'FILE' => 'File',
        'FILES' => 'Files',
        'IMAGE' => 'Image',
        'IMG_RESOURCE' => 'ImageResource',
        'IMGTEXT' => 'ImageText',
        'CONTENT' => 'Content',
        'RECORDS' => 'Records',
        'HMENU' => 'HierarchicalMenu',
        'CTABLE' => 'ContentTable',
        'OTABLE' => 'OffsetTable',
        'COLUMNS' => 'Columns',
        'HRULER' => 'HorizontalRuler',
        'CASEFUNC' => 'Case',
        'LOAD_REGISTER' => 'LoadRegister',
        'RESTORE_REGISTER' => 'RestoreRegister',
        'FORM' => 'Form',
        'SEARCHRESULT' => 'SearchResult',
        'TEMPLATE' => 'Template',
        'FLUIDTEMPLATE' => 'FluidTemplate',
        'MULTIMEDIA' => 'Multimedia',
        'MEDIA' => 'Media',
        'SWFOBJECT' => 'ShockwaveFlashObject',
        'FLOWPLAYER' => 'FlowPlayer',
        'QTOBJECT' => 'QuicktimeObject',
        'SVG' => 'ScalableVectorGraphics',
        'EDITPANEL' => 'EditPanel',
    );

    public $image_compression = array(
        10 => array(
            'params' => '',
            'ext' => 'gif'
        ),
        11 => array(
            'params' => '-colors 128',
            'ext' => 'gif'
        ),
        12 => array(
            'params' => '-colors 64',
            'ext' => 'gif'
        ),
        13 => array(
            'params' => '-colors 32',
            'ext' => 'gif'
        ),
        14 => array(
            'params' => '-colors 16',
            'ext' => 'gif'
        ),
        15 => array(
            'params' => '-colors 8',
            'ext' => 'gif'
        ),
        20 => array(
            'params' => '-quality 100',
            'ext' => 'jpg'
        ),
        21 => array(
            'params' => '-quality 90',
            'ext' => 'jpg'
        ),
        22 => array(
            'params' => '-quality 80',
            'ext' => 'jpg'
        ),
        23 => array(
            'params' => '-quality 70',
            'ext' => 'jpg'
        ),
        24 => array(
            'params' => '-quality 60',
            'ext' => 'jpg'
        ),
        25 => array(
            'params' => '-quality 50',
            'ext' => 'jpg'
        ),
        26 => array(
            'params' => '-quality 40',
            'ext' => 'jpg'
        ),
        27 => array(
            'params' => '-quality 30',
            'ext' => 'jpg'
        ),
        28 => array(
            'params' => '-quality 20',
            'ext' => 'jpg'
        ),
        30 => array(
            'params' => '-colors 256',
            'ext' => 'png'
        ),
        31 => array(
            'params' => '-colors 128',
            'ext' => 'png'
        ),
        32 => array(
            'params' => '-colors 64',
            'ext' => 'png'
        ),
        33 => array(
            'params' => '-colors 32',
            'ext' => 'png'
        ),
        34 => array(
            'params' => '-colors 16',
            'ext' => 'png'
        ),
        35 => array(
            'params' => '-colors 8',
            'ext' => 'png'
        ),
        39 => array(
            'params' => '',
            'ext' => 'png'
        )
    );

    public $image_effects = array(
        1 => '-rotate 90',
        2 => '-rotate 270',
        3 => '-rotate 180',
        10 => '-colorspace GRAY',
        11 => '-sharpen 70',
        20 => '-normalize',
        23 => '-contrast',
        25 => '-gamma 1.3',
        26 => '-gamma 0.8'
    );

    public $data = array();

    protected $table = '';

    // Used for backup...
    public $oldData = array();

    // If this is set with an array before stdWrap, it's used instead of $this->data in the data-property in stdWrap
    public $alternativeData = '';

    // Used by the parseFunc function and is loaded with tag-parameters when parsing tags.
    public $parameters = array();

    public $currentValKey = 'currentValue_kidjls9dksoje';

    // This is set to the [table]:[uid] of the record delivered in the $data-array, if the cObjects CONTENT or RECORD is in operation.
    // Note that $GLOBALS['TSFE']->currentRecord is set to an equal value but always indicating the latest record rendered.
    public $currentRecord = '';

    // Set in cObj->RECORDS and cObj->CONTENT to the current number of records selected in a query.
    public $currentRecordTotal = 0;

    // Incremented in cObj->RECORDS and cObj->CONTENT before each record rendering.
    public $currentRecordNumber = 0;

    // Incremented in parent cObj->RECORDS and cObj->CONTENT before each record rendering.
    public $parentRecordNumber = 0;

    // If the ContentObjectRender was started from CONTENT, RECORD or SEARCHRESULT cObject's this array has two keys, 'data' and 'currentRecord' which indicates the record and data for the parent cObj.
    public $parentRecord = array();

    // This may be set as a reference to the calling object of eg. cObjGetSingle. Anyway, just use it as you like. It's used in productsLib.inc for example.
    public $regObj;

    // internal
    // Is set to 1 if the instance of this cObj is executed from a *_INT plugin (see pagegen, bottom of document)
    public $INT_include = 0;

    // This is used by checkPid, that checks if pages are accessible. The $checkPid_cache['page_uid'] is set TRUE or FALSE upon this check featuring a caching function for the next request.
    public $checkPid_cache = array();

    public $checkPid_badDoktypeList = '255';

    // This will be set by typoLink() to the url of the most recent link created.
    public $lastTypoLinkUrl = '';

    // DO. link target.
    public $lastTypoLinkTarget = '';

    public $lastTypoLinkLD = array();

    // Caching substituteMarkerArrayCached function
    public $substMarkerCache = array();

    // array that registers rendered content elements (or any table) to make sure they are not rendered recursively!
    public $recordRegister = array();

    // Containing hooks for userdefined cObjects
    protected $cObjHookObjectsRegistry = array();

    public $cObjHookObjectsArr = array();

    // Containing hook objects for stdWrap
    protected $stdWrapHookObjects = array();

    // Containing hook objects for getImgResource
    protected $getImgResourceHookObjects;

    protected $currentFile = NULL;

    public $doConvertToUserIntObject = FALSE;

    protected $userObjectType = FALSE;

    protected $stopRendering = array();

    protected $stdWrapRecursionLevel = 0;

    const OBJECTTYPE_USER_INT = 1;
    const OBJECTTYPE_USER = 2;
    public function start($data, $table = '') {
        global $TYPO3_CONF_VARS;
        if ($TYPO3_CONF_VARS['FE']['activateContentAdapter'] && is_array($data) && !empty($data) && !empty($table)) {
            \TYPO3\CMS\Core\Resource\Service\FrontendContentAdapterService::modifyDBRow($data, $table);
        }
        $this->data = $data;
        $this->table = $table;
        $this->currentRecord = $table ? $table . ':' . $this->data['uid'] : '';
        $this->parameters = array();
        if (is_array($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClass'])) {
            foreach ($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClass'] as $classArr) {
                $this->cObjHookObjectsRegistry[$classArr[0]] = $classArr[1];
            }
        }
        $this->stdWrapHookObjects = array();
        if (is_array($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['stdWrap'])) {
            foreach ($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['stdWrap'] as $classData) {
                $hookObject = GeneralUtility::getUserObj($classData);
                if (!$hookObject instanceof \TYPO3\CMS\Frontend\ContentObject\ContentObjectStdWrapHookInterface) {
                    throw new \UnexpectedValueException($classData . ' must implement interface TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectStdWrapHookInterface', 1195043965);
                }
                $this->stdWrapHookObjects[] = $hookObject;
            }
        }
        if (is_array($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['postInit'])) {
            foreach ($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['postInit'] as $classData) {
                $postInitializationProcessor = GeneralUtility::getUserObj($classData);
                if (!$postInitializationProcessor instanceof \TYPO3\CMS\Frontend\ContentObject\ContentObjectPostInitHookInterface) {
                    throw new \UnexpectedValueException($classData . ' must implement interface TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectPostInitHookInterface', 1274563549);
                }
                $postInitializationProcessor->postProcessContentObjectInitialization($this);
            }
        }
    }

    public function getCurrentTable() {
        return $this->table;
    }

    protected function getGetImgResourceHookObjects() {
        if (!isset($this->getImgResourceHookObjects)) {
            $this->getImgResourceHookObjects = array();
            if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getImgResource'])) {
                foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getImgResource'] as $classData) {
                    $hookObject = GeneralUtility::getUserObj($classData);
                    if (!$hookObject instanceof \TYPO3\CMS\Frontend\ContentObject\ContentObjectGetImageResourceHookInterface) {
                        throw new \UnexpectedValueException('$hookObject must implement interface TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectGetImageResourceHookInterface', 1218636383);
                    }
                    $this->getImgResourceHookObjects[] = $hookObject;
                }
            }
        }
        return $this->getImgResourceHookObjects;
    }

    public function setParent($data, $currentRecord) {
        $this->parentRecord = array(
            'data' => $data,
            'currentRecord' => $currentRecord
        );
    }

    /***********************************************
     *
     * CONTENT_OBJ:
     *
     ***********************************************/
    public function getCurrentVal() {
        return $this->data[$this->currentValKey];
    }

    public function setCurrentVal($value) {
        $this->data[$this->currentValKey] = $value;
    }

    public function cObjGet($setup, $addKey = '') {
        if (is_array($setup)) {
            $sKeyArray = \TYPO3\CMS\Core\TypoScript\TemplateService::sortedKeyList($setup);
            $content = '';
            foreach ($sKeyArray as $theKey) {
                $theValue = $setup[$theKey];
                if ((int)$theKey && strpos($theKey, '.') === FALSE) {
                    $conf = $setup[$theKey . '.'];
                    $content .= $this->cObjGetSingle($theValue, $conf, $addKey . $theKey);
                }
            }
            return $content;
        }
    }

    public function cObjGetSingle($name, $conf, $TSkey = '__') {
        global $TYPO3_CONF_VARS;
        $content = '';
        // Checking that the function is not called eternally. This is done by interrupting at a depth of 100
        $GLOBALS['TSFE']->cObjectDepthCounter--;
        if ($GLOBALS['TSFE']->cObjectDepthCounter > 0) {
            $name = trim($name);
            if ($GLOBALS['TT']->LR) {
                $GLOBALS['TT']->push($TSkey, $name);
            }
            // Checking if the COBJ is a reference to another object. (eg. name of 'blabla.blabla = < styles.something')
            if ($name[0] === '<') {
                $key = trim(substr($name, 1));
                $cF = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\TypoScript\\Parser\\TypoScriptParser');
                // $name and $conf is loaded with the referenced values.
                $confOverride = is_array($conf) ? $conf : array();
                list($name, $conf) = $cF->getVal($key, $GLOBALS['TSFE']->tmpl->setup);
                $conf = array_replace_recursive(is_array($conf) ? $conf : array(), $confOverride);
                // Getting the cObject
                $GLOBALS['TT']->incStackPointer();
                $content .= $this->cObjGetSingle($name, $conf, $key);
                $GLOBALS['TT']->decStackPointer();
            } else {
                $hooked = FALSE;
                // Application defined cObjects
                if (!empty($this->cObjHookObjectsRegistry[$name])) {
                    if (empty($this->cObjHookObjectsArr[$name])) {
                        $this->cObjHookObjectsArr[$name] = GeneralUtility::getUserObj($this->cObjHookObjectsRegistry[$name]);
                    }
                    $hookObj = $this->cObjHookObjectsArr[$name];
                    if (method_exists($hookObj, 'cObjGetSingleExt')) {
                        $content .= $hookObj->cObjGetSingleExt($name, $conf, $TSkey, $this);
                        $hooked = TRUE;
                    }
                }
                if (!$hooked) {
                    $contentObject = $this->getContentObject($name);
                    if ($contentObject) {
                        $content .= $contentObject->render($conf);
                    } else {
                        // Call hook functions for extra processing
                        if ($name && is_array($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClassDefault'])) {
                            foreach ($TYPO3_CONF_VARS['SC_OPTIONS']['tslib/class.tslib_content.php']['cObjTypeAndClassDefault'] as $classData) {
                                $hookObject = GeneralUtility::getUserObj($classData);
                                if (!$hookObject instanceof \TYPO3\CMS\Frontend\ContentObject\ContentObjectGetSingleHookInterface) {
                                    throw new \UnexpectedValueException('$hookObject must implement interface TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectGetSingleHookInterface', 1195043731);
                                }
                                $content .= $hookObject->getSingleContentObject($name, (array) $conf, $TSkey, $this);
                            }
                        } else {
                            // Log error in AdminPanel
                            $warning = sprintf('Content Object "%s" does not exist', $name);
                            $GLOBALS['TT']->setTSlogMessage($warning, 2);
                        }
                    }
                }
            }
            if ($GLOBALS['TT']->LR) {
                $GLOBALS['TT']->pull($content);
            }
        }
        // Increasing on exit...
        $GLOBALS['TSFE']->cObjectDepthCounter++;
        return $content;
    }

    public function getContentObject($name) {
        if (!isset($this->contentObjectClassMapping[$name])) {
            return NULL;
        }
        $fullyQualifiedClassName = 'TYPO3\\CMS\\Frontend\\ContentObject\\' . $this->contentObjectClassMapping[$name] . 'ContentObject';
        return GeneralUtility::makeInstance($fullyQualifiedClassName, $this);
    }

    /********************************************
     *
     * Functions rendering content objects (cObjects)
     *
     ********************************************/

    public function FLOWPLAYER($conf) {
        return $this->getContentObject('FLOWPLAYER')->render($conf);
    }

    public function TEXT($conf) {
        return $this->getContentObject('TEXT')->render($conf);
    }

    public function CLEARGIF($conf) {
        return $this->getContentObject('CLEARGIF')->render($conf);
    }

    public function COBJ_ARRAY($conf, $ext = '') {
        if ($ext === 'INT') {
            return $this->getContentObject('COA_INT')->render($conf);
        } else {
            return $this->getContentObject('COA')->render($conf);
        }
    }

    public function USER($conf, $ext = '') {
        if ($ext === 'INT') {
            return $this->getContentObject('USER_INT')->render($conf);
        } else {
            return $this->getContentObject('USER')->render($conf);
        }
    }

    public function getUserObjectType() {
        return $this->userObjectType;
    }

    public function setUserObjectType($userObjectType) {
        $this->userObjectType = $userObjectType;
    }

    public function convertToUserIntObject() {
        if ($this->userObjectType !== self::OBJECTTYPE_USER) {
            $GLOBALS['TT']->setTSlogMessage('TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectRenderer::convertToUserIntObject() ' . 'is called in the wrong context or for the wrong object type', 2);
        } else {
            $this->doConvertToUserIntObject = TRUE;
        }
    }

    public function FILE($conf) {
        return $this->getContentObject('FILE')->render($conf);
    }

    public function FILES($conf) {
        return $this->getContentObject('FILES')->render($conf);
    }

    public function IMAGE($conf) {
        return $this->getContentObject('IMAGE')->render($conf);
    }

    public function IMG_RESOURCE($conf) {
        return $this->getContentObject('IMG_RESOURCE')->render($conf);
    }

    public function IMGTEXT($conf) {
        return $this->getContentObject('IMGTEXT')->render($conf);
    }

    public function CONTENT($conf) {
        return $this->getContentObject('CONTENT')->render($conf);
    }

    public function RECORDS($conf) {
        return $this->getContentObject('RECORDS')->render($conf);
    }

    public function HMENU($conf) {
        return $this->getContentObject('HMENU')->render($conf);
    }

    public function CTABLE($conf) {
        return $this->getContentObject('CTABLE')->render($conf);
    }

    public function OTABLE($conf) {
        return $this->getContentObject('OTABLE')->render($conf);
    }

    public function COLUMNS($conf) {
        return $this->getContentObject('COLUMNS')->render($conf);
    }

    public function HRULER($conf) {
        return $this->getContentObject('HRULER')->render($conf);
    }

    public function CASEFUNC($conf) {
        return $this->getContentObject('CASE')->render($conf);
    }

    public function LOAD_REGISTER($conf, $name) {
        if ($name === 'RESTORE_REGISTER') {
            return $this->getContentObject('RESTORE_REGISTER')->render();
        } else {
            return $this->getContentObject('LOAD_REGISTER')->render($conf);
        }
    }

    public function FORM($conf, $formData = '') {
        return $this->getContentObject('FORM')->render($conf, $formData);
    }

    public function SEARCHRESULT($conf) {
        return $this->getContentObject('SEARCHRESULT')->render($conf);
    }

    public function TEMPLATE($conf) {
        return $this->getContentObject('TEMPLATE')->render($conf);
    }

    protected function FLUIDTEMPLATE(array $conf) {
        return $this->getContentObject('FLUIDTEMPLATE')->render($conf);
    }

    public function MULTIMEDIA($conf) {
        return $this->getContentObject('MULTIMEDIA')->render($conf);
    }

    public function MEDIA($conf) {
        return $this->getContentObject('MEDIA')->render($conf);
    }

    public function SWFOBJECT($conf) {
        return $this->getContentObject('SWFOBJECT')->render($conf);
    }

    public function QTOBJECT($conf) {
        return $this->getContentObject('QTOBJECT')->render($conf);
    }

    public function SVG($conf) {
        return $this->getContentObject('SVG')->render($conf);
    }

    /************************************
     *
     * Various helper functions for content objects:
     *
     ************************************/
    public function readFlexformIntoConf($flexData, &$conf, $recursive = FALSE) {
        if ($recursive === FALSE && is_string($flexData)) {
            $flexData = GeneralUtility::xml2array($flexData, 'T3');
        }
        if (is_array($flexData) && isset($flexData['data']['sDEF']['lDEF'])) {
            $flexData = $flexData['data']['sDEF']['lDEF'];
        }
        if (!is_array($flexData)) {
            return;
        }
        foreach ($flexData as $key => $value) {
            if (!is_array($value)) {
                continue;
            }
            if (isset($value['el'])) {
                if (is_array($value['el']) && count($value['el']) > 0) {
                    foreach ($value['el'] as $ekey => $element) {
                        if (isset($element['vDEF'])) {
                            $conf[$ekey] = $element['vDEF'];
                        } else {
                            if (is_array($element)) {
                                $this->readFlexformIntoConf($element, $conf[$key][key($element)][$ekey], TRUE);
                            } else {
                                $this->readFlexformIntoConf($element, $conf[$key][$ekey], TRUE);
                            }
                        }
                    }
                } else {
                    $this->readFlexformIntoConf($value['el'], $conf[$key], TRUE);
                }
            }
            if (isset($value['vDEF'])) {
                $conf[$key] = $value['vDEF'];
            }
        }
    }

    public function getSlidePids($pidList, $pidConf) {
        $pidList = isset($pidConf) ? trim($this->stdWrap($pidList, $pidConf)) : trim($pidList);
        if ($pidList === '') {
            $pidList = 'this';
        }
        if (trim($pidList)) {
            $listArr = GeneralUtility::intExplode(',', str_replace('this', $GLOBALS['TSFE']->contentPid, $pidList));
            $listArr = $this->checkPidArray($listArr);
        }
        $pidList = array();
        if (is_array($listArr) && count($listArr)) {
            foreach ($listArr as $uid) {
                $page = $GLOBALS['TSFE']->sys_page->getPage($uid);
                if (!$page['is_siteroot']) {
                    $pidList[] = $page['pid'];
                }
            }
        }
        return implode(',', $pidList);
    }

    public function getFieldDefaultValue($noValueInsert, $fieldName, $defaultVal) {
        if (!$GLOBALS['TSFE']->no_cache || !isset($_POST[$fieldName]) && !isset($_GET[$fieldName]) || $noValueInsert) {
            return $defaultVal;
        } else {
            return GeneralUtility::_GP($fieldName);
        }
    }

    public function cImage($file, $conf) {
        $info = $this->getImgResource($file, $conf['file.']);
        $GLOBALS['TSFE']->lastImageInfo = $info;
        if (!is_array($info)) {
            return '';
        }
        if (is_file(PATH_site . $info['3'])) {
            $source = GeneralUtility::rawUrlEncodeFP(GeneralUtility::png_to_gif_by_imagemagick($info[3]));
            $source = $GLOBALS['TSFE']->absRefPrefix . $source;
        } else {
            $source = $info[3];
        }

        $layoutKey = $this->stdWrap($conf['layoutKey'], $conf['layoutKey.']);
        $imageTagTemplate = $this->getImageTagTemplate($layoutKey, $conf);
        $sourceCollection = $this->getImageSourceCollection($layoutKey, $conf, $file);

        // This array is used to collect the image-refs on the page...
        $GLOBALS['TSFE']->imagesOnPage[] = $source;
        $altParam = $this->getAltParam($conf);
        $params = $this->stdWrapValue('params', $conf);
        if ($params !== '' && $params{0} !== ' ') {
            $params = ' ' . $params;
        }

        $imageTagValues = array(
            'width' =>  $info[0],
            'height' => $info[1],
            'src' => htmlspecialchars($source),
            'params' => $params,
            'altParams' => $altParam,
            'border' =>  $this->getBorderAttr(' border="' . (int)$conf['border'] . '"'),
            'sourceCollection' => $sourceCollection,
            'selfClosingTagSlash' => (!empty($GLOBALS['TSFE']->xhtmlDoctype) ? ' /' : ''),
        );

        $theValue = $this->substituteMarkerArray($imageTagTemplate, $imageTagValues, '###|###', TRUE, TRUE);

        $linkWrap = isset($conf['linkWrap.']) ? $this->stdWrap($conf['linkWrap'], $conf['linkWrap.']) : $conf['linkWrap'];
        if ($linkWrap) {
            $theValue = $this->linkWrap($theValue, $linkWrap);
        } elseif ($conf['imageLinkWrap']) {
            $originalFile = !empty($info['originalFile']) ? $info['originalFile'] : $info['origFile'];
            $theValue = $this->imageLinkWrap($theValue, $originalFile, $conf['imageLinkWrap.']);
        }
        $wrap = isset($conf['wrap.']) ? $this->stdWrap($conf['wrap'], $conf['wrap.']) : $conf['wrap'];
        if ($wrap) {
            $theValue = $this->wrap($theValue, $conf['wrap']);
        }
        return $theValue;
    }

    public function getBorderAttr($borderAttr) {
        if (!GeneralUtility::inList('xhtml_strict,xhtml_11,xhtml_2', $GLOBALS['TSFE']->xhtmlDoctype) && $GLOBALS['TSFE']->config['config']['doctype'] != 'html5' && !$GLOBALS['TSFE']->config['config']['disableImgBorderAttr']) {
            return $borderAttr;
        }
    }

    public function getImageTagTemplate($layoutKey, $conf) {
        if ($layoutKey && isset($conf['layout.']) && isset($conf['layout.'][$layoutKey . '.'])) {
            $imageTagLayout = $this->stdWrap($conf['layout.'][$layoutKey . '.']['element'], $conf['layout.'][$layoutKey . '.']['element.']);
        } else {
            $imageTagLayout = '<img src="###SRC###" width="###WIDTH###" height="###HEIGHT###" ###PARAMS### ###ALTPARAMS### ###BORDER######SELFCLOSINGTAGSLASH###>';
        }
        return $imageTagLayout;
    }

    public function getImageSourceCollection($layoutKey, $conf, $file) {
        $sourceCollection = '';
        if ($layoutKey && $conf['sourceCollection.'] && ($conf['layout.'][$layoutKey . '.']['source'] || $conf['layout.'][$layoutKey . '.']['source.'])) {

            // find active sourceCollection
            $activeSourceCollections = array();
            foreach ($conf['sourceCollection.'] as $sourceCollectionKey => $sourceCollectionConfiguration) {
                if (substr($sourceCollectionKey, -1) == '.') {
                    if (empty($sourceCollectionConfiguration['if.']) || $this->checkIf($sourceCollectionConfiguration['if.'])) {
                        $activeSourceCollections[] = $sourceCollectionConfiguration;
                    }
                }
            }

            // apply option split to configurations
            $srcLayoutOptionSplitted = $GLOBALS['TSFE']->tmpl->splitConfArray($conf['layout.'][$layoutKey . '.'], count($activeSourceCollections));

            // render sources
            foreach ($activeSourceCollections as $key => $sourceConfiguration) {
                $sourceLayout = $this->stdWrap($srcLayoutOptionSplitted[$key]['source'], $srcLayoutOptionSplitted[$key]['source.']);

                $sourceRenderConfiguration = array (
                    'file' => $file,
                    'file.' => $conf['file.']
                );

                if (isset($sourceConfiguration['pixelDensity'])) {
                    $pixelDensity = (int)$this->stdWrap($sourceConfiguration['pixelDensity'], $sourceConfiguration['pixelDensity.']);
                } else {
                    $pixelDensity = 1;
                }
                $dimensionKeys = array('width', 'height', 'maxW', 'minW', 'maxH', 'minH');
                foreach ($dimensionKeys as $dimensionKey) {
                    $dimension = $this->stdWrap($sourceConfiguration[$dimensionKey], $sourceConfiguration[$dimensionKey . '.']);
                    if (!$dimension) {
                        $dimension = $this->stdWrap($conf['file.'][$dimensionKey], $conf['file.'][$dimensionKey . '.']);
                    }
                    if ($dimension) {
                        if (strstr($dimension, 'c') !== FALSE && ($dimensionKey === 'width' || $dimensionKey === 'height')) {
                            $dimensionParts = explode('c', $dimension, 2);
                            $dimension = (int)($dimensionParts[0] * $pixelDensity) . 'c';
                            if ($dimensionParts[1]) {
                                $dimension .= $dimensionParts[1];
                            }
                        } else {
                            $dimension = (int)($dimension * $pixelDensity);
                        }
                        $sourceRenderConfiguration['file.'][$dimensionKey] = $dimension;
                        // Remove the stdWrap properties for dimension as they have been processed already above.
                        unset($sourceRenderConfiguration['file.'][$dimensionKey . '.']);
                    }
                }
                $sourceInfo = $this->getImgResource($sourceRenderConfiguration['file'], $sourceRenderConfiguration['file.']);
                if ($sourceInfo) {
                    $sourceConfiguration['width'] = $sourceInfo[0];
                    $sourceConfiguration['height'] = $sourceInfo[1];
                    $urlPrefix = '';
                    if (parse_url($sourceInfo[3], PHP_URL_HOST) === NULL) {
                        $urlPrefix = $GLOBALS['TSFE']->absRefPrefix;
                    }
                    $sourceConfiguration['src'] = htmlspecialchars($urlPrefix . $sourceInfo[3]);
                    $sourceConfiguration['selfClosingTagSlash'] = (!empty($GLOBALS['TSFE']->xhtmlDoctype) ? ' /' : '');

                    $oneSourceCollection = $this->substituteMarkerArray($sourceLayout, $sourceConfiguration, '###|###', TRUE, TRUE);

                    if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getImageSourceCollection'])) {
                        foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getImageSourceCollection'] as $classData) {
                            $hookObject = GeneralUtility::getUserObj($classData);
                            if (!$hookObject instanceof ContentObjectOneSourceCollectionHookInterface) {
                                throw new \UnexpectedValueException(
                                    '$hookObject must implement interface TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectOneSourceCollectionHookInterface',
                                    1380007853
                                );
                            }
                            $oneSourceCollection = $hookObject->getOneSourceCollection((array) $sourceRenderConfiguration, (array) $sourceConfiguration, $oneSourceCollection, $this);
                        }
                    }

                    $sourceCollection .= $oneSourceCollection;
                }
            }
        }
        return $sourceCollection;
    }

    public function imageLinkWrap($string, $imageFile, $conf) {
        $a1 = '';
        $a2 = '';
        $content = $string;
        $enable = isset($conf['enable.']) ? $this->stdWrap($conf['enable'], $conf['enable.']) : $conf['enable'];
        if ($enable) {
            $content = $this->typolink($string, $conf['typolink.']);
            if (isset($conf['file.'])) {
                $imageFile = $this->stdWrap($imageFile, $conf['file.']);
            }

            if ($imageFile instanceof \TYPO3\CMS\Core\Resource\File) {
                $file = $imageFile;
            } elseif ($imageFile instanceof \TYPO3\CMS\Core\Resource\FileReference) {
                $file = $imageFile->getOriginalFile();
            } else {
                if (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($imageFile)) {
                    $file = \TYPO3\CMS\Core\Resource\ResourceFactory::getInstance()->getFileObject((int)$imageFile);
                } else {
                    $file = \TYPO3\CMS\Core\Resource\ResourceFactory::getInstance()->getFileObjectFromCombinedIdentifier($imageFile);
                }
            }

            // Create imageFileLink if not created with typolink
            if ($content == $string) {
                $parameterNames = array('width', 'height', 'effects', 'bodyTag', 'title', 'wrap');
                $parameters = array();
                $sample = isset($conf['sample.']) ? $this->stdWrap($conf['sample'], $conf['sample.']) : $conf['sample'];
                if ($sample) {
                    $parameters['sample'] = 1;
                }
                foreach ($parameterNames as $parameterName) {
                    if (isset($conf[$parameterName . '.'])) {
                        $conf[$parameterName] = $this->stdWrap($conf[$parameterName], $conf[$parameterName . '.']);
                    }
                    if (isset($conf[$parameterName]) && $conf[$parameterName]) {
                        $parameters[$parameterName] = $conf[$parameterName];
                    }
                }
                $parametersEncoded = base64_encode(serialize($parameters));
                $hmac = GeneralUtility::hmac(implode('|', array($file->getUid(), $parametersEncoded)));
                $params = '&md5=' . $hmac;
                foreach (str_split($parametersEncoded, 64) as $index => $chunk) {
                    $params .= '&parameters' . rawurlencode('[') . $index . rawurlencode(']') . '=' . rawurlencode($chunk);
                }
                $url = $GLOBALS['TSFE']->absRefPrefix . 'index.php?eID=tx_cms_showpic&file=' . $file->getUid() . $params;
                $directImageLink = isset($conf['directImageLink.']) ? $this->stdWrap($conf['directImageLink'], $conf['directImageLink.']) : $conf['directImageLink'];
                if ($directImageLink) {
                    $imgResourceConf = array(
                        'file' => $imageFile,
                        'file.' => $conf
                    );
                    $url = $this->IMG_RESOURCE($imgResourceConf);
                    if (!$url) {
                        // If no imagemagick / gm is available
                        $url = $imageFile;
                    }
                }
                // Create TARGET-attribute only if the right doctype is used
                if (!GeneralUtility::inList('xhtml_strict,xhtml_11,xhtml_2', $GLOBALS['TSFE']->xhtmlDoctype)) {
                    $target = isset($conf['target.']) ? $this->stdWrap($conf['target'], $conf['target.']) : $conf['target'];
                    if ($target) {
                        $target = ' target="' . htmlspecialchars($target) . '"';
                    } else {
                        $target = ' target="thePicture"';
                    }
                } else {
                    $target = '';
                }
                $conf['JSwindow'] = isset($conf['JSwindow.']) ? $this->stdWrap($conf['JSwindow'], $conf['JSwindow.']) : $conf['JSwindow'];
                if ($conf['JSwindow']) {
                    if ($conf['JSwindow.']['altUrl'] || $conf['JSwindow.']['altUrl.']) {
                        $altUrl = isset($conf['JSwindow.']['altUrl.']) ? $this->stdWrap($conf['JSwindow.']['altUrl'], $conf['JSwindow.']['altUrl.']) : $conf['JSwindow.']['altUrl'];
                        if ($altUrl) {
                            $url = $altUrl . ($conf['JSwindow.']['altUrl_noDefaultParams'] ? '' : '?file=' . rawurlencode($imageFile) . $params);
                        }
                    }

                    $processedFile = $file->process('Image.CropScaleMask', $conf);
                    $JSwindowExpand = isset($conf['JSwindow.']['expand.']) ? $this->stdWrap($conf['JSwindow.']['expand'], $conf['JSwindow.']['expand.']) : $conf['JSwindow.']['expand'];
                    $offset = GeneralUtility::intExplode(',', $JSwindowExpand . ',');
                    $newWindow = isset($conf['JSwindow.']['newWindow.']) ? $this->stdWrap($conf['JSwindow.']['newWindow'], $conf['JSwindow.']['newWindow.']) : $conf['JSwindow.']['newWindow'];
                    $a1 = '<a href="' . htmlspecialchars($url) . '" onclick="' . htmlspecialchars(('openPic(\'' . $GLOBALS['TSFE']->baseUrlWrap($url) . '\',\'' . ($newWindow ? md5($url) : 'thePicture') . '\',\'width=' . ($processedFile->getProperty('width') + $offset[0]) . ',height=' . ($processedFile->getProperty('height') + $offset[1]) . ',status=0,menubar=0\'); return false;')) . '"' . $target . $GLOBALS['TSFE']->ATagParams . '>';
                    $a2 = '</a>';
                    $GLOBALS['TSFE']->setJS('openPic');
                } else {
                    $conf['linkParams.']['parameter'] = $url;
                    $string = $this->typoLink($string, $conf['linkParams.']);
                }
                if (isset($conf['stdWrap.'])) {
                    $string = $this->stdWrap($string, $conf['stdWrap.']);
                }
                $content = $a1 . $string . $a2;
            }
        }
        return $content;
    }

    public function fileResource($fName, $addParams = 'alt="" title=""') {
        $incFile = $GLOBALS['TSFE']->tmpl->getFileName($fName);
        if ($incFile && file_exists($incFile)) {
            $fileinfo = GeneralUtility::split_fileref($incFile);
            if (GeneralUtility::inList('jpg,gif,jpeg,png', $fileinfo['fileext'])) {
                $imgFile = $incFile;
                $imgInfo = @getImageSize($imgFile);
                return '<img src="' . htmlspecialchars($GLOBALS['TSFE']->absRefPrefix . $imgFile) . '" width="' . $imgInfo[0] . '" height="' . $imgInfo[1] . '"' . $this->getBorderAttr(' border="0"') . ' ' . $addParams . ' />';
            } elseif (filesize($incFile) < 1024 * 1024) {
                return $GLOBALS['TSFE']->tmpl->fileContent($incFile);
            }
        }
    }

    public function lastChanged($tstamp) {
        $tstamp = (int)$tstamp;
        if ($tstamp > (int)$GLOBALS['TSFE']->register['SYS_LASTCHANGED']) {
            $GLOBALS['TSFE']->register['SYS_LASTCHANGED'] = $tstamp;
        }
    }

    public function linkWrap($content, $wrap) {
        $wrapArr = explode('|', $wrap);
        if (preg_match('/\\{([0-9]*)\\}/', $wrapArr[0], $reg)) {
            if ($uid = $GLOBALS['TSFE']->tmpl->rootLine[$reg[1]]['uid']) {
                $wrapArr[0] = str_replace($reg[0], $uid, $wrapArr[0]);
            }
        }
        return trim($wrapArr[0]) . $content . trim($wrapArr[1]);
    }

    public function getAltParam($conf, $longDesc = TRUE) {
        $altText = isset($conf['altText.']) ? trim($this->stdWrap($conf['altText'], $conf['altText.'])) : trim($conf['altText']);
        $titleText = isset($conf['titleText.']) ? trim($this->stdWrap($conf['titleText'], $conf['titleText.'])) : trim($conf['titleText']);
        if (isset($conf['longdescURL.']) && $GLOBALS['TSFE']->config['config']['doctype'] != 'html5') {
            $longDesc = $this->typoLink_URL($conf['longdescURL.']);
        } else {
            $longDesc = trim($conf['longdescURL']);
        }
        $longDescUrl = strip_tags($longDescUrl);
        // "alt":
        $altParam = ' alt="' . htmlspecialchars($altText) . '"';
        // "title":
        $emptyTitleHandling = 'useAlt';
        $emptyTitleHandling = isset($conf['emptyTitleHandling.']) ? $this->stdWrap($conf['emptyTitleHandling'], $conf['emptyTitleHandling.']) : $conf['emptyTitleHandling'];
        // Choices: 'keepEmpty' | 'useAlt' | 'removeAttr'
        if ($titleText || $emptyTitleHandling == 'keepEmpty') {
            $altParam .= ' title="' . htmlspecialchars($titleText) . '"';
        } elseif (!$titleText && $emptyTitleHandling == 'useAlt') {
            $altParam .= ' title="' . htmlspecialchars($altText) . '"';
        }
        // "longDesc" URL
        if ($longDesc && !empty($longDescUrl)) {
            $altParam .= ' longdesc="' . htmlspecialchars($longDescUrl) . '"';
        }
        return $altParam;
    }

    public function cleanFormName($name) {
        // Turn data[x][y] into data:x:y:
        $name = preg_replace('/\\[|\\]\\[?/', ':', trim($name));
        // Remove illegal chars like _
        return preg_replace('#[^:a-zA-Z0-9]#', '', $name);
    }

    public function getATagParams($conf, $addGlobal = 1) {
        $aTagParams = '';
        if ($conf['ATagParams.']) {
            $aTagParams = ' ' . $this->stdWrap($conf['ATagParams'], $conf['ATagParams.']);
        } elseif ($conf['ATagParams']) {
            $aTagParams = ' ' . $conf['ATagParams'];
        }
        if ($addGlobal) {
            $aTagParams = ' ' . trim(($GLOBALS['TSFE']->ATagParams . $aTagParams));
        }
        // Extend params
        if (isset($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getATagParamsPostProc']) && is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getATagParamsPostProc'])) {
            $_params = array(
                'conf' => &$conf,
                'aTagParams' => &$aTagParams
            );
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getATagParamsPostProc'] as $objRef) {
                $processor =& GeneralUtility::getUserObj($objRef);
                $aTagParams = $processor->process($_params, $this);
            }
        }

        $aTagParams = trim($aTagParams);
        if (!empty($aTagParams)) {
            $aTagParams = ' ' . $aTagParams;
        }

        return $aTagParams;
    }

    public function extLinkATagParams($URL, $TYPE) {
        $out = '';
        if ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['extLinkATagParamsHandler']) {
            $extLinkATagParamsHandler = GeneralUtility::getUserObj($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['extLinkATagParamsHandler']);
            if (method_exists($extLinkATagParamsHandler, 'main')) {
                $out .= trim($extLinkATagParamsHandler->main($URL, $TYPE, $this));
            }
        }
        return trim($out) ? ' ' . trim($out) : '';
    }

    /***********************************************
     *
     * HTML template processing functions
     *
     ***********************************************/
    public function getSubpart($content, $marker) {
        return \TYPO3\CMS\Core\Html\HtmlParser::getSubpart($content, $marker);
    }

    public function substituteSubpart($content, $marker, $subpartContent, $recursive = 1) {
        return \TYPO3\CMS\Core\Html\HtmlParser::substituteSubpart($content, $marker, $subpartContent, $recursive);
    }

    public function substituteSubpartArray($content, array $subpartsContent) {
        return \TYPO3\CMS\Core\Html\HtmlParser::substituteSubpartArray($content, $subpartsContent);
    }

    public function substituteMarker($content, $marker, $markContent) {
        return \TYPO3\CMS\Core\Html\HtmlParser::substituteMarker($content, $marker, $markContent);
    }

    public function substituteMarkerArrayCached($content, array $markContentArray = NULL, array $subpartContentArray = NULL, array $wrappedSubpartContentArray = NULL) {
        $GLOBALS['TT']->push('substituteMarkerArrayCached');
        // If not arrays then set them
        if (is_null($markContentArray)) {
            // Plain markers
            $markContentArray = array();
        }
        if (is_null($subpartContentArray)) {
            // Subparts being directly substituted
            $subpartContentArray = array();
        }
        if (is_null($wrappedSubpartContentArray)) {
            // Subparts being wrapped
            $wrappedSubpartContentArray = array();
        }
        // Finding keys and check hash:
        $sPkeys = array_keys($subpartContentArray);
        $wPkeys = array_keys($wrappedSubpartContentArray);
        $keysToReplace = array_merge(array_keys($markContentArray), $sPkeys, $wPkeys);
        if (empty($keysToReplace)) {
            $GLOBALS['TT']->pull();
            return $content;
        }
        asort($keysToReplace);
        $storeKey = md5('substituteMarkerArrayCached_storeKey:' . serialize(array(
            $content,
            $keysToReplace
        )));
        if ($this->substMarkerCache[$storeKey]) {
            $storeArr = $this->substMarkerCache[$storeKey];
            $GLOBALS['TT']->setTSlogMessage('Cached', 0);
        } else {
            $storeArrDat = $GLOBALS['TSFE']->sys_page->getHash($storeKey);
            if (is_array($storeArrDat)) {
                $storeArr = $storeArrDat;
                // Setting cache:
                $this->substMarkerCache[$storeKey] = $storeArr;
                $GLOBALS['TT']->setTSlogMessage('Cached from DB', 0);
            } else {
                // Finding subparts and substituting them with the subpart as a marker
                foreach ($sPkeys as $sPK) {
                    $content = $this->substituteSubpart($content, $sPK, $sPK);
                }
                // Finding subparts and wrapping them with markers
                foreach ($wPkeys as $wPK) {
                    $content = $this->substituteSubpart($content, $wPK, array(
                        $wPK,
                        $wPK
                    ));
                }

                $storeArr = array();
                $result = preg_match_all('/###([^#](?:[^#]*+|#{1,2}[^#])+)###/', $content, $markersInContent);
                if ($result !== FALSE && !empty($markersInContent[1])) {
                    $keysToReplaceFlipped = array_flip($keysToReplace);
                    $regexKeys = array();
                    $wrappedKeys = array();
                    // Traverse keys and quote them for reg ex.
                    foreach ($markersInContent[1] as $key) {
                        if (isset($keysToReplaceFlipped['###' . $key . '###'])) {
                            $regexKeys[] = preg_quote($key, '/');
                            $wrappedKeys[] = '###' . $key . '###';
                        }
                    }
                    $regex = '/###(?:' . implode('|', $regexKeys) . ')###/';
                    $storeArr['c'] = preg_split($regex, $content); // contains all content parts around markers
                    $storeArr['k'] = $wrappedKeys; // contains all markers incl. ###
                    // Setting cache:
                    $this->substMarkerCache[$storeKey] = $storeArr;
                    // Storing the cached data:
                    $GLOBALS['TSFE']->sys_page->storeHash($storeKey, $storeArr, 'substMarkArrayCached');
                }
                $GLOBALS['TT']->setTSlogMessage('Parsing', 0);
            }
        }
        if (!empty($storeArr['k']) && is_array($storeArr['k'])) {
            // Substitution/Merging:
            // Merging content types together, resetting
            $valueArr = array_merge($markContentArray, $subpartContentArray, $wrappedSubpartContentArray);
            $wSCA_reg = array();
            $content = '';
            // Traversing the keyList array and merging the static and dynamic content
            foreach ($storeArr['k'] as $n => $keyN) {
                // add content before marker
                $content .= $storeArr['c'][$n];
                if (!is_array($valueArr[$keyN])) {
                    // fetch marker replacement from $markContentArray or $subpartContentArray
                    $content .= $valueArr[$keyN];
                } else {
                    if (!isset($wSCA_reg[$keyN])) {
                        $wSCA_reg[$keyN] = 0;
                    }
                    // fetch marker replacement from $wrappedSubpartContentArray
                    $content .= $valueArr[$keyN][$wSCA_reg[$keyN] % 2];
                    $wSCA_reg[$keyN]++;
                }
            }
            // add remaining content
            $content .= $storeArr['c'][count($storeArr['k'])];
        }
        $GLOBALS['TT']->pull();
        return $content;
    }

    public function substituteMarkerArray($content, array $markContentArray, $wrap = '', $uppercase = FALSE, $deleteUnused = FALSE) {
        return \TYPO3\CMS\Core\Html\HtmlParser::substituteMarkerArray($content, $markContentArray, $wrap, $uppercase, $deleteUnused);
    }

    public function substituteMarkerInObject(&$tree, array $markContentArray) {
        if (is_array($tree)) {
            foreach ($tree as $key => $value) {
                $this->substituteMarkerInObject($tree[$key], $markContentArray);
            }
        } else {
            $tree = $this->substituteMarkerArray($tree, $markContentArray);
        }
        return $tree;
    }

    public function substituteMarkerAndSubpartArrayRecursive($content, array $markersAndSubparts, $wrap = '', $uppercase = FALSE, $deleteUnused = FALSE) {
        return \TYPO3\CMS\Core\Html\HtmlParser::substituteMarkerAndSubpartArrayRecursive($content, $markersAndSubparts, $wrap, $uppercase, $deleteUnused);
    }

    public function fillInMarkerArray(array $markContentArray, array $row, $fieldList = '', $nl2br = TRUE, $prefix = 'FIELD_', $HSC = FALSE) {
        if ($fieldList) {
            $fArr = GeneralUtility::trimExplode(',', $fieldList, TRUE);
            foreach ($fArr as $field) {
                $markContentArray['###' . $prefix . $field . '###'] = $nl2br ? nl2br($row[$field], !empty($GLOBALS['TSFE']->xhtmlDoctype)) : $row[$field];
            }
        } else {
            if (is_array($row)) {
                foreach ($row as $field => $value) {
                    if (!\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($field)) {
                        if ($HSC) {
                            $value = htmlspecialchars($value);
                        }
                        $markContentArray['###' . $prefix . $field . '###'] = $nl2br ? nl2br($value, !empty($GLOBALS['TSFE']->xhtmlDoctype)) : $value;
                    }
                }
            }
        }
        return $markContentArray;
    }

    public function setCurrentFile($fileObject) {
        $this->currentFile = $fileObject;
    }

    public function getCurrentFile() {
        return $this->currentFile;
    }

    /***********************************************
     *
     * "stdWrap" + sub functions
     *
     ***********************************************/
    public function stdWrap($content = '', $conf = array()) {
        // If there is any hook object, activate all of the process and override functions.
        // The hook interface ContentObjectStdWrapHookInterface takes care that all 4 methods exist.
        if ($this->stdWrapHookObjects) {
            $conf['stdWrapPreProcess'] = 1;
            $conf['stdWrapOverride'] = 1;
            $conf['stdWrapProcess'] = 1;
            $conf['stdWrapPostProcess'] = 1;
        }

        if (!is_array($conf) || !$conf) {
            return $content;
        }

        // Cache handling
        if (is_array($conf['cache.'])) {
            $conf['cache.']['key'] = $this->stdWrap($conf['cache.']['key'], $conf['cache.']['key.']);
            $conf['cache.']['tags'] = $this->stdWrap($conf['cache.']['tags'], $conf['cache.']['tags.']);
            $conf['cache.']['lifetime'] = $this->stdWrap($conf['cache.']['lifetime'], $conf['cache.']['lifetime.']);
            $conf['cacheRead'] = 1;
            $conf['cacheStore'] = 1;
        }
        // Check, which of the available stdWrap functions is needed for the current conf Array
        // and keep only those but still in the same order
        $sortedConf = array_intersect_key($this->stdWrapOrder, $conf);
        // Functions types that should not make use of nested stdWrap function calls to avoid conflicts with internal TypoScript used by these functions
        $stdWrapDisabledFunctionTypes = 'cObject,functionName,stdWrap';
        // Additional Array to check whether a function has already been executed
        $isExecuted = array();
        // Additional switch to make sure 'required', 'if' and 'fieldRequired'
        // will still stop rendering immediately in case they return FALSE
        $this->stdWrapRecursionLevel++;
        $this->stopRendering[$this->stdWrapRecursionLevel] = FALSE;
        // execute each function in the predefined order
        foreach ($sortedConf as $stdWrapName => $functionType) {
            // eliminate the second key of a pair 'key'|'key.' to make sure functions get called only once and check if rendering has been stopped
            if (!$isExecuted[$stdWrapName] && !$this->stopRendering[$this->stdWrapRecursionLevel]) {
                $functionName = rtrim($stdWrapName, '.');
                $functionProperties = $functionName . '.';
                // If there is any code one the next level, check if it contains "official" stdWrap functions
                // if yes, execute them first - will make each function stdWrap aware
                // so additional stdWrap calls within the functions can be removed, since the result will be the same
                // exception: the recursive stdWrap function and cObject will still be using their own stdWrap call, since it modifies the content and not a property
                if (count($conf[$functionProperties]) && !GeneralUtility::inList($stdWrapDisabledFunctionTypes, $functionType)) {
                    if (array_intersect_key($this->stdWrapOrder, $conf[$functionProperties])) {
                        $conf[$functionName] = $this->stdWrap($conf[$functionName], $conf[$functionProperties]);
                    }
                }
                // Check if key is still containing something, since it might have been changed by next level stdWrap before
                if ((isset($conf[$functionName]) || $conf[$functionProperties]) && ($functionType !== 'boolean' || $conf[$functionName])) {
                    // Get just that part of $conf that is needed for the particular function
                    $singleConf = array(
                        $functionName => $conf[$functionName],
                        $functionProperties => $conf[$functionProperties]
                    );
                    // In this special case 'spaceBefore' and 'spaceAfter' need additional stuff from 'space.''
                    if ($functionName === 'spaceBefore' || $functionName === 'spaceAfter') {
                        $singleConf['space.'] = $conf['space.'];
                    }
                    // Hand over the whole $conf array to the stdWrapHookObjects
                    if ($functionType === 'hook') {
                        $singleConf = $conf;
                    }
                    // Add both keys - with and without the dot - to the set of executed functions
                    $isExecuted[$functionName] = TRUE;
                    $isExecuted[$functionProperties] = TRUE;
                    // Call the function with the prefix stdWrap_ to make sure nobody can execute functions just by adding their name to the TS Array
                    $functionName = 'stdWrap_' . $functionName;
                    $content = $this->{$functionName}($content, $singleConf);
                } elseif ($functionType == 'boolean' && !$conf[$functionName]) {
                    $isExecuted[$functionName] = TRUE;
                    $isExecuted[$functionProperties] = TRUE;
                }
            }
        }
        unset($this->stopRendering[$this->stdWrapRecursionLevel]);
        $this->stdWrapRecursionLevel--;

        return $content;
    }

    public function stdWrapValue($key, array $config, $defaultValue = '') {
        if (isset($config[$key])) {
            if (!isset($config[$key . '.'])) {
                return $config[$key];
            }
        } elseif (isset($config[$key . '.'])) {
            $config[$key] = '';
        } else {
            return $defaultValue;
        }
        $stdWrapped = $this->stdWrap($config[$key], $config[$key . '.']);
        return $stdWrapped ?: $defaultValue;
    }

    public function stdWrap_stdWrapPreProcess($content = '', $conf = array()) {
        foreach ($this->stdWrapHookObjects as $hookObject) {
            $content = $hookObject->stdWrapPreProcess($content, $conf, $this);
        }
        return $content;
    }

    public function stdWrap_cacheRead($content = '', $conf = array()) {
        if (!empty($conf['cache.']['key'])) {
            $cacheFrontend = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager')->getCache('cache_hash');
            if ($cacheFrontend && $cacheFrontend->has($conf['cache.']['key'])) {
                $content = $cacheFrontend->get($conf['cache.']['key']);
                $this->stopRendering[$this->stdWrapRecursionLevel] = TRUE;
            }
        }
        return $content;
    }

    public function stdWrap_addPageCacheTags($content = '', $conf = array()) {
        $tags = isset($conf['addPageCacheTags.'])
            ? $this->stdWrap($conf['addPageCacheTags'], $conf['addPageCacheTags.'])
            : $conf['addPageCacheTags'];
        if (!empty($tags)) {
            $cacheTags = GeneralUtility::trimExplode(',', $tags, TRUE);
            $GLOBALS['TSFE']->addCacheTags($cacheTags);
        }
        return $content;
    }

    public function stdWrap_setContentToCurrent($content = '', $conf = array()) {
        $this->data[$this->currentValKey] = $content;
        return $content;
    }

    public function stdWrap_setCurrent($content = '', $conf = array()) {
        $this->data[$this->currentValKey] = $conf['setCurrent'];
        return $content;
    }

    public function stdWrap_lang($content = '', $conf = array()) {
        if (isset($conf['lang.']) && $GLOBALS['TSFE']->config['config']['language'] && isset($conf['lang.'][$GLOBALS['TSFE']->config['config']['language']])) {
            $content = $conf['lang.'][$GLOBALS['TSFE']->config['config']['language']];
        }
        return $content;
    }

    public function stdWrap_data($content = '', $conf = array()) {
        $content = $this->getData($conf['data'], is_array($this->alternativeData) ? $this->alternativeData : $this->data);
        // This must be unset directly after
        $this->alternativeData = '';
        return $content;
    }

    public function stdWrap_field($content = '', $conf = array()) {
        return $this->getFieldVal($conf['field']);
    }

    public function stdWrap_current($content = '', $conf = array()) {
        return $this->data[$this->currentValKey];
    }

    public function stdWrap_cObject($content = '', $conf = array()) {
        return $this->cObjGetSingle($conf['cObject'], $conf['cObject.'], '/stdWrap/.cObject');
    }

    public function stdWrap_numRows($content = '', $conf = array()) {
        return $this->numRows($conf['numRows.']);
    }

    public function stdWrap_filelist($content = '', $conf = array()) {
        return $this->filelist($conf['filelist']);
    }

    public function stdWrap_preUserFunc($content = '', $conf = array()) {
        return $this->callUserFunction($conf['preUserFunc'], $conf['preUserFunc.'], $content);
    }

    public function stdWrap_stdWrapOverride($content = '', $conf = array()) {
        foreach ($this->stdWrapHookObjects as $hookObject) {
            $content = $hookObject->stdWrapOverride($content, $conf, $this);
        }
        return $content;
    }

    public function stdWrap_override($content = '', $conf = array()) {
        if (trim($conf['override'])) {
            $content = $conf['override'];
        }
        return $content;
    }

    public function stdWrap_preIfEmptyListNum($content = '', $conf = array()) {
        return $this->listNum($content, $conf['preIfEmptyListNum'], $conf['preIfEmptyListNum.']['splitChar']);
    }

    public function stdWrap_ifNull($content = '', $conf = array()) {
        return $content !== NULL ? $content : $conf['ifNull'];
    }

    public function stdWrap_ifEmpty($content = '', $conf = array()) {
        if (!trim($content)) {
            $content = $conf['ifEmpty'];
        }
        return $content;
    }

    public function stdWrap_ifBlank($content = '', $conf = array()) {
        if (!strlen(trim($content))) {
            $content = $conf['ifBlank'];
        }
        return $content;
    }

    public function stdWrap_listNum($content = '', $conf = array()) {
        return $this->listNum($content, $conf['listNum'], $conf['listNum.']['splitChar']);
    }

    public function stdWrap_trim($content = '', $conf = array()) {
        return trim($content);
    }

    public function stdWrap_strPad($content = '', $conf = array()) {
        // Must specify a length in conf for this to make sense
        $length = 0;
        // Padding with space is PHP-default
        $padWith = ' ';
        // Padding on the right side is PHP-default
        $padType = STR_PAD_RIGHT;
        if (!empty($conf['strPad.']['length'])) {
            $length = isset($conf['strPad.']['length.']) ? $this->stdWrap($conf['strPad.']['length'], $conf['strPad.']['length.']) : $conf['strPad.']['length'];
            $length = (int)$length;
        }
        if (isset($conf['strPad.']['padWith']) && strlen($conf['strPad.']['padWith']) > 0) {
            $padWith = isset($conf['strPad.']['padWith.']) ? $this->stdWrap($conf['strPad.']['padWith'], $conf['strPad.']['padWith.']) : $conf['strPad.']['padWith'];
        }
        if (!empty($conf['strPad.']['type'])) {
            $type = isset($conf['strPad.']['type.']) ? $this->stdWrap($conf['strPad.']['type'], $conf['strPad.']['type.']) : $conf['strPad.']['type'];
            if (strtolower($type) === 'left') {
                $padType = STR_PAD_LEFT;
            } elseif (strtolower($type) === 'both') {
                $padType = STR_PAD_BOTH;
            }
        }
        $content = str_pad($content, $length, $padWith, $padType);
        return $content;
    }

    public function stdWrap_stdWrap($content = '', $conf = array()) {
        return $this->stdWrap($content, $conf['stdWrap.']);
    }

    public function stdWrap_stdWrapProcess($content = '', $conf = array()) {
        foreach ($this->stdWrapHookObjects as $hookObject) {
            $content = $hookObject->stdWrapProcess($content, $conf, $this);
        }
        return $content;
    }

    public function stdWrap_required($content = '', $conf = array()) {
        if ((string) $content === '') {
            $content = '';
            $this->stopRendering[$this->stdWrapRecursionLevel] = TRUE;
        }
        return $content;
    }

    public function stdWrap_if($content = '', $conf = array()) {
        if (empty($conf['if.']) || $this->checkIf($conf['if.'])) {
            return $content;
        }
        $this->stopRendering[$this->stdWrapRecursionLevel] = TRUE;
        return '';
    }

    public function stdWrap_fieldRequired($content = '', $conf = array()) {
        if (!trim($this->data[$conf['fieldRequired']])) {
            $content = '';
            $this->stopRendering[$this->stdWrapRecursionLevel] = TRUE;
        }
        return $content;
    }

    public function stdWrap_csConv($content = '', $conf = array()) {
        return $GLOBALS['TSFE']->csConv($content, $conf['csConv']);
    }

    public function stdWrap_parseFunc($content = '', $conf = array()) {
        return $this->parseFunc($content, $conf['parseFunc.'], $conf['parseFunc']);
    }

    public function stdWrap_HTMLparser($content = '', $conf = array()) {
        if (is_array($conf['HTMLparser.'])) {
            $content = $this->HTMLparser_TSbridge($content, $conf['HTMLparser.']);
        }
        return $content;
    }

    public function stdWrap_split($content = '', $conf = array()) {
        return $this->splitObj($content, $conf['split.']);
    }

    public function stdWrap_replacement($content = '', $conf = array()) {
        return $this->replacement($content, $conf['replacement.']);
    }

    public function stdWrap_prioriCalc($content = '', $conf = array()) {
        $content = \TYPO3\CMS\Core\Utility\MathUtility::calculateWithParentheses($content);
        if ($conf['prioriCalc'] == 'intval') {
            $content = (int)$content;
        }
        return $content;
    }

    public function stdWrap_char($content = '', $conf = array()) {
        return chr((int)$conf['char']);
    }

    public function stdWrap_intval($content = '', $conf = array()) {
        return (int)$content;
    }

    public function stdWrap_hash($content = '', array $conf = array()) {
        $algorithm = isset($conf['hash.']) ? $this->stdWrap($conf['hash'], $conf['hash.']) : $conf['hash'];
        if (function_exists('hash') && in_array($algorithm, hash_algos())) {
            $content = hash($algorithm, $content);
        } else {
            // Non-existing hashing algorithm
            $content = '';
        }
        return $content;
    }

    public function stdWrap_round($content = '', $conf = array()) {
        return $this->round($content, $conf['round.']);
    }

    public function stdWrap_numberFormat($content = '', $conf = array()) {
        return $this->numberFormat($content, $conf['numberFormat.']);
    }

    public function stdWrap_expandList($content = '', $conf = array()) {
        return GeneralUtility::expandList($content);
    }

    public function stdWrap_date($content = '', $conf = array()) {
        // Check for zero length string to mimic default case of date/gmdate.
        $content = $content == '' ? $GLOBALS['EXEC_TIME'] : (int)$content;
        $content = $conf['date.']['GMT'] ? gmdate($conf['date'], $content) : date($conf['date'], $content);
        return $content;
    }

    public function stdWrap_strftime($content = '', $conf = array()) {
            // Check for zero length string to mimic default case of strtime/gmstrftime
        $content = $content == '' ? $GLOBALS['EXEC_TIME'] : (int)$content;
        $content = $conf['strftime.']['GMT'] ? gmstrftime($conf['strftime'], $content) : strftime($conf['strftime'], $content);
        $tmp_charset = $conf['strftime.']['charset'] ? $conf['strftime.']['charset'] : $GLOBALS['TSFE']->localeCharset;
        if ($tmp_charset) {
            $content = $GLOBALS['TSFE']->csConv($content, $tmp_charset);
        }
        return $content;
    }

    public function stdWrap_age($content = '', $conf = array()) {
        return $this->calcAge($GLOBALS['EXEC_TIME'] - $content, $conf['age']);
    }

    public function stdWrap_case($content = '', $conf = array()) {
        return $this->HTMLcaseshift($content, $conf['case']);
    }

    public function stdWrap_bytes($content = '', $conf = array()) {
        return GeneralUtility::formatSize($content, $conf['bytes.']['labels']);
    }

    public function stdWrap_substring($content = '', $conf = array()) {
        return $this->substring($content, $conf['substring']);
    }

    public function stdWrap_removeBadHTML($content = '', $conf = array()) {
        return $this->removeBadHTML($content, $conf['removeBadHTML.']);
    }

    public function stdWrap_cropHTML($content = '', $conf = array()) {
        return $this->cropHTML($content, $conf['cropHTML']);
    }

    public function stdWrap_stripHtml($content = '', $conf = array()) {
        return strip_tags($content);
    }

    public function stdWrap_crop($content = '', $conf = array()) {
        return $this->crop($content, $conf['crop']);
    }

    public function stdWrap_rawUrlEncode($content = '', $conf = array()) {
        return rawurlencode($content);
    }

    public function stdWrap_htmlSpecialChars($content = '', $conf = array()) {
        if (!empty($conf['htmlSpecialChars.']['preserveEntities'])) {
            $content = htmlspecialchars($content, ENT_COMPAT, 'UTF-8', FALSE);
        } else {
            $content = htmlspecialchars($content);
        }
        return $content;
    }

    public function stdWrap_encodeForJavaScriptValue($content = '', $conf = array()) {
        return GeneralUtility::quoteJSvalue($content);
    }

    public function stdWrap_doubleBrTag($content = '', $conf = array()) {
        return preg_replace('/
?
[    ]*
?
/', $conf['doubleBrTag'], $content);
    }

    public function stdWrap_br($content = '', $conf = array()) {
        return nl2br($content, !empty($GLOBALS['TSFE']->xhtmlDoctype));
    }

    public function stdWrap_brTag($content = '', $conf = array()) {
        return str_replace(LF, $conf['brTag'], $content);
    }

    public function stdWrap_encapsLines($content = '', $conf = array()) {
        return $this->encaps_lineSplit($content, $conf['encapsLines.']);
    }

    public function stdWrap_keywords($content = '', $conf = array()) {
        return $this->keywords($content);
    }

    public function stdWrap_innerWrap($content = '', $conf = array()) {
        return $this->wrap($content, $conf['innerWrap']);
    }

    public function stdWrap_innerWrap2($content = '', $conf = array()) {
        return $this->wrap($content, $conf['innerWrap2']);
    }

    public function stdWrap_fontTag($content = '', $conf = array()) {
        return $this->wrap($content, $conf['fontTag']);
    }

    public function stdWrap_addParams($content = '', $conf = array()) {
        return $this->addParams($content, $conf['addParams.']);
    }

    public function stdWrap_textStyle($content = '', $conf = array()) {
        return $this->textStyle($content, $conf['textStyle.']);
    }

    public function stdWrap_tableStyle($content = '', $conf = array()) {
        return $this->tableStyle($content, $conf['tableStyle.']);
    }

    public function stdWrap_filelink($content = '', $conf = array()) {
        return $this->filelink($content, $conf['filelink.']);
    }

    public function stdWrap_preCObject($content = '', $conf = array()) {
        return $this->cObjGetSingle($conf['preCObject'], $conf['preCObject.'], '/stdWrap/.preCObject') . $content;
    }

    public function stdWrap_postCObject($content = '', $conf = array()) {
        return $content . $this->cObjGetSingle($conf['postCObject'], $conf['postCObject.'], '/stdWrap/.postCObject');
    }

    public function stdWrap_wrapAlign($content = '', $conf = array()) {
        $wrapAlign = trim($conf['wrapAlign']);
        if ($wrapAlign) {
            $content = $this->wrap($content, '<div style="text-align:' . htmlspecialchars($wrapAlign) . ';">|</div>');
        }
        return $content;
    }

    public function stdWrap_typolink($content = '', $conf = array()) {
        return $this->typolink($content, $conf['typolink.']);
    }

    public function stdWrap_TCAselectItem($content = '', $conf = array()) {
        if (is_array($conf['TCAselectItem.'])) {
            $content = $this->TCAlookup($content, $conf['TCAselectItem.']);
        }
        return $content;
    }

    public function stdWrap_spaceBefore($content = '', $conf = array()) {
        return $this->wrapSpace($content, trim($conf['spaceBefore']) . '|', $conf['space.']);
    }

    public function stdWrap_spaceAfter($content = '', $conf = array()) {
        return $this->wrapSpace($content, '|' . trim($conf['spaceAfter']), $conf['space.']);
    }

    public function stdWrap_space($content = '', $conf = array()) {
        return $this->wrapSpace($content, trim($conf['space']), $conf['space.']);
    }

    public function stdWrap_wrap($content = '', $conf = array()) {
        return $this->wrap($content, $conf['wrap'], $conf['wrap.']['splitChar'] ? $conf['wrap.']['splitChar'] : '|');
    }

    public function stdWrap_noTrimWrap($content = '', $conf = array()) {
        $splitChar = isset($conf['noTrimWrap.']['splitChar.'])
            ? $this->stdWrap($conf['noTrimWrap.']['splitChar'], $conf['noTrimWrap.']['splitChar.'])
            : $conf['noTrimWrap.']['splitChar'];
        if ($splitChar === NULL || $splitChar === '') {
            $splitChar = '|';
        }
        $content = $this->noTrimWrap(
            $content,
            $conf['noTrimWrap'],
            $splitChar
        );
        return $content;
    }

    public function stdWrap_wrap2($content = '', $conf = array()) {
        return $this->wrap($content, $conf['wrap2'], $conf['wrap2.']['splitChar'] ? $conf['wrap2.']['splitChar'] : '|');
    }

    public function stdWrap_dataWrap($content = '', $conf = array()) {
        return $this->dataWrap($content, $conf['dataWrap']);
    }

    public function stdWrap_prepend($content = '', $conf = array()) {
        return $this->cObjGetSingle($conf['prepend'], $conf['prepend.'], '/stdWrap/.prepend') . $content;
    }

    public function stdWrap_append($content = '', $conf = array()) {
        return $content . $this->cObjGetSingle($conf['append'], $conf['append.'], '/stdWrap/.append');
    }

    public function stdWrap_wrap3($content = '', $conf = array()) {
        return $this->wrap($content, $conf['wrap3'], $conf['wrap3.']['splitChar'] ? $conf['wrap3.']['splitChar'] : '|');
    }

    public function stdWrap_orderedStdWrap($content = '', $conf = array()) {
        $sortedKeysArray = \TYPO3\CMS\Core\TypoScript\TemplateService::sortedKeyList($conf['orderedStdWrap.'], TRUE);
        foreach ($sortedKeysArray as $key) {
            $content = $this->stdWrap($content, $conf['orderedStdWrap.'][$key . '.']);
        }
        return $content;
    }

    public function stdWrap_outerWrap($content = '', $conf = array()) {
        return $this->wrap($content, $conf['outerWrap']);
    }

    public function stdWrap_insertData($content = '', $conf = array()) {
        return $this->insertData($content);
    }

    public function stdWrap_offsetWrap($content = '', $conf = array()) {
        $controlTable = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\ContentObject\\OffsetTableContentObject');
        if ($conf['offsetWrap.']['tableParams'] || $conf['offsetWrap.']['tableParams.']) {
            $controlTable->tableParams = isset($conf['offsetWrap.']['tableParams.']) ? $this->stdWrap($conf['offsetWrap.']['tableParams'], $conf['offsetWrap.']['tableParams.']) : $conf['offsetWrap.']['tableParams'];
        }
        if ($conf['offsetWrap.']['tdParams'] || $conf['offsetWrap.']['tdParams.']) {
            $controlTable->tdParams = ' ' . (isset($conf['offsetWrap.']['tdParams.']) ? $this->stdWrap($conf['offsetWrap.']['tdParams'], $conf['offsetWrap.']['tdParams.']) : $conf['offsetWrap.']['tdParams']);
        }
        $content = $controlTable->start($content, $conf['offsetWrap']);
        if ($conf['offsetWrap.']['stdWrap.']) {
            $content = $this->stdWrap($content, $conf['offsetWrap.']['stdWrap.']);
        }
        return $content;
    }

    public function stdWrap_postUserFunc($content = '', $conf = array()) {
        return $this->callUserFunction($conf['postUserFunc'], $conf['postUserFunc.'], $content);
    }

    public function stdWrap_postUserFuncInt($content = '', $conf = array()) {
        $substKey = 'INT_SCRIPT.' . $GLOBALS['TSFE']->uniqueHash();
        $GLOBALS['TSFE']->config['INTincScript'][$substKey] = array(
            'content' => $content,
            'postUserFunc' => $conf['postUserFuncInt'],
            'conf' => $conf['postUserFuncInt.'],
            'type' => 'POSTUSERFUNC',
            'cObj' => serialize($this)
        );
        $content = '<!--' . $substKey . '-->';
        return $content;
    }

    public function stdWrap_prefixComment($content = '', $conf = array()) {
        if (!$GLOBALS['TSFE']->config['config']['disablePrefixComment'] && !empty($conf['prefixComment'])) {
            $content = $this->prefixComment($conf['prefixComment'], array(), $content);
        }
        return $content;
    }

    public function stdWrap_editIcons($content = '', $conf = array()) {
        if ($GLOBALS['TSFE']->beUserLogin && $conf['editIcons']) {
            if (!is_array($conf['editIcons.'])) {
                $conf['editIcons.'] = array();
            }
            $content = $this->editIcons($content, $conf['editIcons'], $conf['editIcons.']);
        }
        return $content;
    }

    public function stdWrap_editPanel($content = '', $conf = array()) {
        if ($GLOBALS['TSFE']->beUserLogin) {
            $content = $this->editPanel($content, $conf['editPanel.']);
        }
        return $content;
    }

    public function stdWrap_cacheStore($content = '', $conf = array()) {
        if (!empty($conf['cache.']['key'])) {
            $cacheFrontend = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Cache\\CacheManager')->getCache('cache_hash');
            if ($cacheFrontend) {
                $tags = !empty($conf['cache.']['tags']) ? GeneralUtility::trimExplode(',', $conf['cache.']['tags']) : array();
                if (strtolower($conf['cache.']['lifetime']) == 'unlimited') {
                    // unlimited
                    $lifetime = 0;
                } elseif (strtolower($conf['cache.']['lifetime']) == 'default') {
                    // default lifetime
                    $lifetime = NULL;
                } elseif ((int)$conf['cache.']['lifetime'] > 0) {
                    // lifetime in seconds
                    $lifetime = (int)$conf['cache.']['lifetime'];
                } else {
                    // default lifetime
                    $lifetime = NULL;
                }
                if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['stdWrap_cacheStore'])) {
                    foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['stdWrap_cacheStore'] as $_funcRef) {
                        $params = array(
                            'key' => $conf['cache.']['key'],
                            'content' => $content,
                            'lifetime' => $lifetime,
                            'tags' => $tags
                        );
                        GeneralUtility::callUserFunction($_funcRef, $params, $this);
                    }
                }
                $cacheFrontend->set($conf['cache.']['key'], $content, $tags, $lifetime);
            }
        }
        return $content;
    }

    public function stdWrap_stdWrapPostProcess($content = '', $conf = array()) {
        foreach ($this->stdWrapHookObjects as $hookObject) {
            $content = $hookObject->stdWrapPostProcess($content, $conf, $this);
        }
        return $content;
    }

    public function stdWrap_debug($content = '', $conf = array()) {
        return '<pre>' . htmlspecialchars($content) . '</pre>';
    }

    public function stdWrap_debugFunc($content = '', $conf = array()) {
        debug($conf['debugFunc'] == 2 ? array(
            $content
        ) : $content);
        return $content;
    }

    public function stdWrap_debugData($content = '', $conf = array()) {
        debug($this->data, '$cObj->data:');
        if (is_array($this->alternativeData)) {
            debug($this->alternativeData, '$this->alternativeData');
        }
        return $content;
    }

    public function numRows($conf) {
        $result = FALSE;
        $conf['select.']['selectFields'] = 'count(*)';
        $res = $this->exec_getQuery($conf['table'], $conf['select.']);
        if ($error = $GLOBALS['TYPO3_DB']->sql_error()) {
            $GLOBALS['TT']->setTSlogMessage($error, 3);
        } else {
            $row = $GLOBALS['TYPO3_DB']->sql_fetch_row($res);
            $result = (int)$row[0];
        }
        $GLOBALS['TYPO3_DB']->sql_free_result($res);
        return $result;
    }

    public function listNum($content, $listNum, $char) {
        $char = $char ?: ',';
        if (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($char)) {
            $char = chr($char);
        }
        $temp = explode($char, $content);
        $last = '' . (count($temp) - 1);
        // Take a random item if requested
        if ($listNum === 'rand') {
            $listNum = rand(0, count($temp) - 1);
        }
        $index = $this->calc(str_ireplace('last', $last, $listNum));
        return $temp[$index];
    }

    public function checkIf($conf) {
        if (!is_array($conf)) {
            return TRUE;
        }
        if (isset($conf['directReturn'])) {
            return $conf['directReturn'] ? 1 : 0;
        }
        $flag = TRUE;
        if (isset($conf['isNull.'])) {
            $isNull = $this->stdWrap('', $conf['isNull.']);
            if ($isNull !== NULL) {
                $flag = 0;
            }
        }
        if (isset($conf['isTrue']) || isset($conf['isTrue.'])) {
            $isTrue = isset($conf['isTrue.']) ? trim($this->stdWrap($conf['isTrue'], $conf['isTrue.'])) : trim($conf['isTrue']);
            if (!$isTrue) {
                $flag = 0;
            }
        }
        if (isset($conf['isFalse']) || isset($conf['isFalse.'])) {
            $isFalse = isset($conf['isFalse.']) ? trim($this->stdWrap($conf['isFalse'], $conf['isFalse.'])) : trim($conf['isFalse']);
            if ($isFalse) {
                $flag = 0;
            }
        }
        if (isset($conf['isPositive']) || isset($conf['isPositive.'])) {
            $number = isset($conf['isPositive.']) ? $this->calc($this->stdWrap($conf['isPositive'], $conf['isPositive.'])) : $this->calc($conf['isPositive']);
            if ($number < 1) {
                $flag = 0;
            }
        }
        if ($flag) {
            $value = isset($conf['value.']) ? trim($this->stdWrap($conf['value'], $conf['value.'])) : trim($conf['value']);
            if (isset($conf['isGreaterThan']) || isset($conf['isGreaterThan.'])) {
                $number = isset($conf['isGreaterThan.']) ? trim($this->stdWrap($conf['isGreaterThan'], $conf['isGreaterThan.'])) : trim($conf['isGreaterThan']);
                if ($number <= $value) {
                    $flag = 0;
                }
            }
            if (isset($conf['isLessThan']) || isset($conf['isLessThan.'])) {
                $number = isset($conf['isLessThan.']) ? trim($this->stdWrap($conf['isLessThan'], $conf['isLessThan.'])) : trim($conf['isLessThan']);
                if ($number >= $value) {
                    $flag = 0;
                }
            }
            if (isset($conf['equals']) || isset($conf['equals.'])) {
                $number = isset($conf['equals.']) ? trim($this->stdWrap($conf['equals'], $conf['equals.'])) : trim($conf['equals']);
                if ($number != $value) {
                    $flag = 0;
                }
            }
            if (isset($conf['isInList']) || isset($conf['isInList.'])) {
                $number = isset($conf['isInList.']) ? trim($this->stdWrap($conf['isInList'], $conf['isInList.'])) : trim($conf['isInList']);
                if (!GeneralUtility::inList($value, $number)) {
                    $flag = 0;
                }
            }
        }
        if ($conf['negate']) {
            $flag = $flag ? 0 : 1;
        }
        return $flag;
    }

    public function filelist($data) {
        $data = trim($data);
        if ($data) {
            $data_arr = explode('|', $data);
            // read directory:
            // MUST exist!
            if ($GLOBALS['TSFE']->lockFilePath) {
                // Cleaning name..., only relative paths accepted.
                $path = $this->clean_directory($data_arr[0]);
                // See if path starts with lockFilePath, the additional '/' is needed because clean_directory gets rid of it
                $path = GeneralUtility::isFirstPartOfStr($path . '/', $GLOBALS['TSFE']->lockFilePath) ? $path : '';
            }
            if ($path) {
                $items = array(
                    'files' => array(),
                    'sorting' => array()
                );
                $ext_list = strtolower(GeneralUtility::uniqueList($data_arr[1]));
                $sorting = trim($data_arr[2]);
                // Read dir:
                $d = @dir($path);
                $tempArray = array();
                if (is_object($d)) {
                    $count = 0;
                    while ($entry = $d->read()) {
                        if ($entry != '.' && $entry != '..') {
                            // Because of odd PHP-error where <br />-tag is sometimes placed after a filename!!
                            $wholePath = $path . '/' . $entry;
                            if (file_exists($wholePath) && filetype($wholePath) == 'file') {
                                $info = GeneralUtility::split_fileref($wholePath);
                                if (!$ext_list || GeneralUtility::inList($ext_list, $info['fileext'])) {
                                    $items['files'][] = $info['file'];
                                    switch ($sorting) {
                                        case 'name':
                                            $items['sorting'][] = strtolower($info['file']);
                                            break;
                                        case 'size':
                                            $items['sorting'][] = filesize($wholePath);
                                            break;
                                        case 'ext':
                                            $items['sorting'][] = $info['fileext'];
                                            break;
                                        case 'date':
                                            $items['sorting'][] = filectime($wholePath);
                                            break;
                                        case 'mdate':
                                            $items['sorting'][] = filemtime($wholePath);
                                            break;
                                        default:
                                            $items['sorting'][] = $count;
                                    }
                                    $count++;
                                }
                            }
                        }
                    }
                    $d->close();
                }
                // Sort if required
                if (count($items['sorting'])) {
                    if (strtolower(trim($data_arr[3])) != 'r') {
                        asort($items['sorting']);
                    } else {
                        arsort($items['sorting']);
                    }
                }
                if (count($items['files'])) {
                    // Make list
                    reset($items['sorting']);
                    $fullPath = trim($data_arr[4]);
                    $list_arr = array();
                    foreach ($items['sorting'] as $key => $v) {
                        $list_arr[] = $fullPath ? $path . '/' . $items['files'][$key] : $items['files'][$key];
                    }
                    return implode(',', $list_arr);
                }
            }
        }
    }

    public function clean_directory($theDir) {
        // proceeds if no '//', '..' or '\' is in the $theFile
        if (GeneralUtility::validPathStr($theDir)) {
            // Removes all dots, slashes and spaces after a path...
            $theDir = preg_replace('/[\\/\\. ]*$/', '', $theDir);
            if (!GeneralUtility::isAbsPath($theDir) && @is_dir($theDir)) {
                return $theDir;
            }
        }
    }

    public function HTMLparser_TSbridge($theValue, $conf) {
        $htmlParser = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Html\\HtmlParser');
        $htmlParserCfg = $htmlParser->HTMLparserConfig($conf);
        return $htmlParser->HTMLcleaner($theValue, $htmlParserCfg[0], $htmlParserCfg[1], $htmlParserCfg[2], $htmlParserCfg[3]);
    }

    public function dataWrap($content, $wrap) {
        return $this->wrap($content, $this->insertData($wrap));
    }

    public function insertData($str) {
        $inside = 0;
        $newVal = '';
        $pointer = 0;
        $totalLen = strlen($str);
        do {
            if (!$inside) {
                $len = strcspn(substr($str, $pointer), '{');
                $newVal .= substr($str, $pointer, $len);
                $inside = 1;
            } else {
                $len = strcspn(substr($str, $pointer), '}') + 1;
                $newVal .= $this->getData(substr($str, $pointer + 1, $len - 2), $this->data);
                $inside = 0;
            }
            $pointer += $len;
        } while ($pointer < $totalLen);
        return $newVal;
    }

    public function prefixComment($str, $conf, $content) {
        if (empty($str)) {
            return $content;
        }
        $parts = explode('|', $str);
        $indent = (int)$parts[0];
        $comment = htmlspecialchars($this->insertData($parts[1]));
        $output = LF
            . str_pad('', $indent, TAB) . '<!-- ' . $comment . ' [begin] -->' . LF
            . str_pad('', ($indent + 1), TAB) . $content . LF
            . str_pad('', $indent, TAB) . '<!-- ' . $comment . ' [end] -->' . LF
            . str_pad('', ($indent + 1), TAB);
        return $output;
    }

    public function substring($content, $options) {
        $options = GeneralUtility::intExplode(',', $options . ',');
        if ($options[1]) {
            return $GLOBALS['TSFE']->csConvObj->substr($GLOBALS['TSFE']->renderCharset, $content, $options[0], $options[1]);
        } else {
            return $GLOBALS['TSFE']->csConvObj->substr($GLOBALS['TSFE']->renderCharset, $content, $options[0]);
        }
    }

    public function crop($content, $options) {
        $options = explode('|', $options);
        $chars = (int)$options[0];
        $afterstring = trim($options[1]);
        $crop2space = trim($options[2]);
        if ($chars) {
            if ($GLOBALS['TSFE']->csConvObj->strlen($GLOBALS['TSFE']->renderCharset, $content) > abs($chars)) {
                $truncatePosition = FALSE;
                if ($chars < 0) {
                    $content = $GLOBALS['TSFE']->csConvObj->substr($GLOBALS['TSFE']->renderCharset, $content, $chars);
                    if ($crop2space) {
                        $truncatePosition = strpos($content, ' ');
                    }
                    $content = $truncatePosition ? $afterstring . substr($content, $truncatePosition) : $afterstring . $content;
                } else {
                    $content = $GLOBALS['TSFE']->csConvObj->substr($GLOBALS['TSFE']->renderCharset, $content, 0, $chars);
                    if ($crop2space) {
                        $truncatePosition = strrpos($content, ' ');
                    }
                    $content = $truncatePosition ? substr($content, 0, $truncatePosition) . $afterstring : $content . $afterstring;
                }
            }
        }
        return $content;
    }

    public function cropHTML($content, $options) {
        $options = explode('|', $options);
        $chars = (int)$options[0];
        $absChars = abs($chars);
        $replacementForEllipsis = trim($options[1]);
        $crop2space = trim($options[2]) === '1' ? TRUE : FALSE;
        // Split $content into an array(even items in the array are outside the tags, odd numbers are tag-blocks).
        $tags = 'a|abbr|address|area|article|aside|audio|b|bdi|bdo|blockquote|body|br|button|caption|cite|code|col|colgroup|data|datalist|dd|del|dfn|div|dl|dt|em|embed|fieldset|figcaption|figure|font|footer|form|h1|h2|h3|h4|h5|h6|header|hr|i|iframe|img|input|ins|kbd|keygen|label|legend|li|link|main|map|mark|meter|nav|object|ol|optgroup|option|output|p|param|pre|progress|q|rb|rp|rt|rtc|ruby|s|samp|section|select|small|source|span|strong|sub|sup|table|tbody|td|textarea|tfoot|th|thead|time|tr|track|u|ul|ut|var|video|wbr';
        $tagsRegEx = '
            (
                (?:
                    <!--.*?-->                  # a comment
                    |
                    <canvas[^>]*>.*?</canvas>   # a canvas tag
                    |
                    <script[^>]*>.*?</script>   # a script tag
                    |
                    <noscript[^>]*>.*?</noscript> # a noscript tag
                    |
                    <template[^>]*>.*?</template> # a template tag
                )
                |
                </?(?:' . $tags . ')+           # opening tag (\'<tag\') or closing tag (\'</tag\')
                (?:
                    (?:
                        (?:
                            \\s+\\w[\\w-]*      # EITHER spaces, followed by attribute names
                            (?:
                                \\s*=?\\s*      # equals
                                (?>
                                    ".*?"       # attribute values in double-quotes
                                    |
                                    \'.*?\'     # attribute values in single-quotes
                                    |
                                    [^\'">\\s]+ # plain attribute values
                                )
                            )?
                        )
                        |                       # OR a single dash (for TYPO3 link tag)
                        (?:
                            \\s+-
                        )
                    )+\\s*
                    |                           # OR only spaces
                    \\s*
                )
                /?>                             # closing the tag with \'>\' or \'/>\'
            )';
        $splittedContent = preg_split('%' . $tagsRegEx . '%xs', $content, -1, PREG_SPLIT_DELIM_CAPTURE);
        // Reverse array if we are cropping from right.
        if ($chars < 0) {
            $splittedContent = array_reverse($splittedContent);
        }
        // Crop the text (chars of tag-blocks are not counted).
        $strLen = 0;
        // This is the offset of the content item which was cropped.
        $croppedOffset = NULL;
        $countSplittedContent = count($splittedContent);
        for ($offset = 0; $offset < $countSplittedContent; $offset++) {
            if ($offset % 2 === 0) {
                $tempContent = $GLOBALS['TSFE']->csConvObj->utf8_encode($splittedContent[$offset], $GLOBALS['TSFE']->renderCharset);
                $thisStrLen = $GLOBALS['TSFE']->csConvObj->strlen('utf-8', html_entity_decode($tempContent, ENT_COMPAT, 'UTF-8'));
                if ($strLen + $thisStrLen > $absChars) {
                    $croppedOffset = $offset;
                    $cropPosition = $absChars - $strLen;
                    // The snippet "&[^&\s;]{2,8};" in the RegEx below represents entities.
                    $patternMatchEntityAsSingleChar = '(&[^&\\s;]{2,8};|.)';
                    $cropRegEx = $chars < 0 ? '#' . $patternMatchEntityAsSingleChar . '{0,' . ($cropPosition + 1) . '}$#uis' : '#^' . $patternMatchEntityAsSingleChar . '{0,' . ($cropPosition + 1) . '}#uis';
                    if (preg_match($cropRegEx, $tempContent, $croppedMatch)) {
                        $tempContentPlusOneCharacter = $croppedMatch[0];
                    } else {
                        $tempContentPlusOneCharacter = FALSE;
                    }
                    $cropRegEx = $chars < 0 ? '#' . $patternMatchEntityAsSingleChar . '{0,' . $cropPosition . '}$#uis' : '#^' . $patternMatchEntityAsSingleChar . '{0,' . $cropPosition . '}#uis';
                    if (preg_match($cropRegEx, $tempContent, $croppedMatch)) {
                        $tempContent = $croppedMatch[0];
                        if ($crop2space && $tempContentPlusOneCharacter !== FALSE) {
                            $cropRegEx = $chars < 0 ? '#(?<=\\s)' . $patternMatchEntityAsSingleChar . '{0,' . $cropPosition . '}$#uis' : '#^' . $patternMatchEntityAsSingleChar . '{0,' . $cropPosition . '}(?=\\s)#uis';
                            if (preg_match($cropRegEx, $tempContentPlusOneCharacter, $croppedMatch)) {
                                $tempContent = $croppedMatch[0];
                            }
                        }
                    }
                    $splittedContent[$offset] = $GLOBALS['TSFE']->csConvObj->utf8_decode($tempContent, $GLOBALS['TSFE']->renderCharset);
                    break;
                } else {
                    $strLen += $thisStrLen;
                }
            }
        }
        // Close cropped tags.
        $closingTags = array();
        if ($croppedOffset !== NULL) {
            $tagName = '';
            $openingTagRegEx = '#^<(\\w+)(?:\\s|>)#';
            $closingTagRegEx = '#^</(\\w+)(?:\\s|>)#';
            for ($offset = $croppedOffset - 1; $offset >= 0; $offset = $offset - 2) {
                if (substr($splittedContent[$offset], -2) === '/>') {
                    // Ignore empty element tags (e.g. <br />).
                    continue;
                }
                preg_match($chars < 0 ? $closingTagRegEx : $openingTagRegEx, $splittedContent[$offset], $matches);
                $tagName = isset($matches[1]) ? $matches[1] : NULL;
                if ($tagName !== NULL) {
                    // Seek for the closing (or opening) tag.
                    $seekingTagName = '';
                    $countSplittedContent = count($splittedContent);
                    for ($seekingOffset = $offset + 2; $seekingOffset < $countSplittedContent; $seekingOffset = $seekingOffset + 2) {
                        preg_match($chars < 0 ? $openingTagRegEx : $closingTagRegEx, $splittedContent[$seekingOffset], $matches);
                        $seekingTagName = isset($matches[1]) ? $matches[1] : NULL;
                        if ($tagName === $seekingTagName) {
                            // We found a matching tag.
                            // Add closing tag only if it occurs after the cropped content item.
                            if ($seekingOffset > $croppedOffset) {
                                $closingTags[] = $splittedContent[$seekingOffset];
                            }
                            break;
                        }
                    }
                }
            }
            // Drop the cropped items of the content array. The $closingTags will be added later on again.
            array_splice($splittedContent, $croppedOffset + 1);
        }
        $splittedContent = array_merge($splittedContent, array(
            $croppedOffset !== NULL ? $replacementForEllipsis : ''
        ), $closingTags);
        // Reverse array once again if we are cropping from the end.
        if ($chars < 0) {
            $splittedContent = array_reverse($splittedContent);
        }
        return implode('', $splittedContent);
    }

    public function removeBadHTML($text, $conf) {
        // Copyright 2002-2003 Thomas Bley
        $text = preg_replace(array(
            '\'<script[^>]*?>.*?</script[^>]*?>\'si',
            '\'<applet[^>]*?>.*?</applet[^>]*?>\'si',
            '\'<object[^>]*?>.*?</object[^>]*?>\'si',
            '\'<iframe[^>]*?>.*?</iframe[^>]*?>\'si',
            '\'<frameset[^>]*?>.*?</frameset[^>]*?>\'si',
            '\'<style[^>]*?>.*?</style[^>]*?>\'si',
            '\'<marquee[^>]*?>.*?</marquee[^>]*?>\'si',
            '\'<script[^>]*?>\'si',
            '\'<meta[^>]*?>\'si',
            '\'<base[^>]*?>\'si',
            '\'<applet[^>]*?>\'si',
            '\'<object[^>]*?>\'si',
            '\'<link[^>]*?>\'si',
            '\'<iframe[^>]*?>\'si',
            '\'<frame[^>]*?>\'si',
            '\'<frameset[^>]*?>\'si',
            '\'<input[^>]*?>\'si',
            '\'<form[^>]*?>\'si',
            '\'<embed[^>]*?>\'si',
            '\'background-image:url\'si',
            '\'<\\w+.*?(onabort|onbeforeunload|onblur|onchange|onclick|ondblclick|ondragdrop|onerror|onfilterchange|onfocus|onhelp|onkeydown|onkeypress|onkeyup|onload|onmousedown|onmousemove|onmouseout|onmouseover|onmouseup|onmove|onreadystatechange|onreset|onresize|onscroll|onselect|onselectstart|onsubmit|onunload).*?>\'si'
        ), '', $text);
        $text = preg_replace('/<a[^>]*href[[:space:]]*=[[:space:]]*["\']?[[:space:]]*javascript[^>]*/i', '', $text);
        // Return clean content
        return $text;
    }

    public function textStyle($theValue, $conf) {
        $conf['face.'][1] = 'Times New Roman';
        $conf['face.'][2] = 'Verdana,Arial,Helvetica,Sans serif';
        $conf['face.'][3] = 'Arial,Helvetica,Sans serif';
        $conf['size.'][1] = 1;
        $conf['size.'][2] = 2;
        $conf['size.'][3] = 3;
        $conf['size.'][4] = 4;
        $conf['size.'][5] = 5;
        $conf['size.'][10] = '+1';
        $conf['size.'][11] = '-1';
        $conf['color.'][240] = 'black';
        $conf['color.'][241] = 'white';
        $conf['color.'][242] = '#333333';
        $conf['color.'][243] = 'gray';
        $conf['color.'][244] = 'silver';
        $conf['color.'][245] = 'red';
        $conf['color.'][246] = 'navy';
        $conf['color.'][247] = 'yellow';
        $conf['color.'][248] = 'green';
        $conf['color.'][249] = 'olive';
        $conf['color.'][250] = 'maroon';
        $face = $this->data[$conf['face.']['field']];
        $size = $this->data[$conf['size.']['field']];
        $color = $this->data[$conf['color.']['field']];
        $align = $this->data[$conf['align.']['field']];
        $properties = $this->data[$conf['properties.']['field']];
        if (!$properties) {
            $properties = isset($conf['properties.']['default.']) ? $this->stdWrap($conf['properties.']['default'], $conf['properties.']['default.']) : $conf['properties.']['default'];
        }
        // Properties
        if ($properties & 8) {
            $theValue = $this->HTMLcaseshift($theValue, 'upper');
        }
        if ($properties & 1) {
            $theValue = '<strong>' . $theValue . '</strong>';
        }
        if ($properties & 2) {
            $theValue = '<i>' . $theValue . '</i>';
        }
        if ($properties & 4) {
            $theValue = '<u>' . $theValue . '</u>';
        }
        // Fonttag
        $theFace = $conf['face.'][$face];
        if (!$theFace) {
            $theFace = isset($conf['face.']['default.']) ? $this->stdWrap($conf['face.']['default'], $conf['face.']['default.']) : $conf['face.']['default'];
        }
        $theSize = $conf['size.'][$size];
        if (!$theSize) {
            $theSize = isset($conf['size.']['default.']) ? $this->stdWrap($conf['size.']['default'], $conf['size.']['default.']) : $conf['size.']['default'];
        }
        $theColor = $conf['color.'][$color];
        if (!$theColor) {
            $theColor = isset($conf['color.']['default.']) ? $this->stdWrap($conf['color.']['default'], $conf['color.']['default.']) : $conf['color.']['default.'];
        }
        if ($conf['altWrap']) {
            $theValue = $this->wrap($theValue, $conf['altWrap']);
        } elseif ($theFace || $theSize || $theColor) {
            $theValue = '<font' . ($theFace ? ' face="' . htmlspecialchars($theFace) . '"' : '') . ($theSize ? ' size="' . (int)$theSize . '"' : '') . ($theColor ? ' color="' . htmlspecialchars($theColor) . '"' : '') . '>' . $theValue . '</font>';
        }
        // Align
        if ($align) {
            $theValue = $this->wrap($theValue, '<div style="text-align:' . htmlspecialchars($align) . ';">|</div>');
        }
        // Return
        return $theValue;
    }

    public function tableStyle($theValue, $conf) {
        $conf['color.'][240] = 'black';
        $conf['color.'][241] = 'white';
        $conf['color.'][242] = '#333333';
        $conf['color.'][243] = 'gray';
        $conf['color.'][244] = 'silver';
        $align = isset($conf['align.']) ? $this->stdWrap($conf['align'], $conf['align.']) : $conf['align'];
        $border = isset($conf['border.']) ? (int)$this->stdWrap($conf['border'], $conf['border.']) : (int)$conf['border'];
        $cellspacing = isset($conf['cellspacing.']) ? (int)$this->stdWrap($conf['cellspacing'], $conf['cellspacing.']) : (int)$conf['cellspacing'];
        $cellpadding = isset($conf['cellpadding.']) ? (int)$this->stdWrap($conf['cellpadding'], $conf['cellpadding.']) : (int)$conf['cellpadding'];
        $color = $this->data[$conf['color.']['field']];
        $theColor = $conf['color.'][$color] ? $conf['color.'][$color] : $conf['color.']['default'];
        // Assembling the table tag
        $tableTagArray = array(
            '<table'
        );
        $tableTagArray[] = 'border="' . (int)$border . '"';
        $tableTagArray[] = 'cellspacing="' . (int)$cellspacing . '"';
        $tableTagArray[] = 'cellpadding="' . (int)$cellpadding . '"';
        if ($align) {
            $tableTagArray[] = 'align="' . htmlspecialchars($align) . '"';
        }
        if ($theColor) {
            $tableTagArray[] = 'bgcolor="' . htmlspecialchars($theColor) . '"';
        }
        if ($conf['params']) {
            $tableTagArray[] = $conf['params'];
        }
        $tableWrap = implode(' ', $tableTagArray) . '> | </table>';
        $theValue = $this->wrap($theValue, $tableWrap);
        // return
        return $theValue;
    }

    public function addParams($content, $conf) {
        // For XHTML compliance.
        $lowerCaseAttributes = TRUE;
        if (!is_array($conf)) {
            return $content;
        }
        $key = 1;
        $parts = explode('<', $content);
        if ((int)$conf['_offset']) {
            $key = (int)$conf['_offset'] < 0 ? count($parts) + (int)$conf['_offset'] : (int)$conf['_offset'];
        }
        $subparts = explode('>', $parts[$key]);
        if (trim($subparts[0])) {
            // Get attributes and name
            $attribs = GeneralUtility::get_tag_attributes('<' . $subparts[0] . '>');
            list($tagName) = explode(' ', $subparts[0], 2);
            // adds/overrides attributes
            foreach ($conf as $pkey => $val) {
                if (substr($pkey, -1) !== '.' && $pkey[0] !== '_') {
                    $tmpVal = isset($conf[$pkey . '.']) ? $this->stdWrap($conf[$pkey], $conf[$pkey . '.']) : (string)$val;
                    if ($lowerCaseAttributes) {
                        $pkey = strtolower($pkey);
                    }
                    if ($tmpVal !== '') {
                        $attribs[$pkey] = $tmpVal;
                    }
                }
            }
            // Re-assembles the tag and content
            $subparts[0] = trim($tagName . ' ' . GeneralUtility::implodeAttributes($attribs));
            $parts[$key] = implode('>', $subparts);
            $content = implode('<', $parts);
        }
        return $content;
    }

    public function filelink($theValue, $conf) {
        $conf['path'] = isset($conf['path.']) ? $this->stdWrap($conf['path'], $conf['path.']) : $conf['path'];
        $theFile = trim($conf['path']) . $theValue;
        if (@is_file($theFile)) {
            $theFileEnc = str_replace('%2F', '/', rawurlencode($theFile));
            $title = $conf['title'];
            if (isset($conf['title.'])) {
                $title = $this->stdWrap($title, $conf['title.']);
            }
            $target = $conf['target'];
            if (isset($conf['target.'])) {
                $target = $this->stdWrap($target, $conf['target.']);
            }
            // The jumpURL feature will be taken care of by typoLink, only "jumpurl.secure = 1" is applyable needed for special link creation
            if ($conf['jumpurl.']['secure']) {
                $alternativeJumpUrlParameter = isset($conf['jumpurl.']['parameter.']) ? $this->stdWrap($conf['jumpurl.']['parameter'], $conf['jumpurl.']['parameter.']) : $conf['jumpurl.']['parameter'];
                $typoLinkConf = array(
                    'parameter' => $alternativeJumpUrlParameter ? $alternativeJumpUrlParameter : $GLOBALS['TSFE']->id . ',' . $GLOBALS['TSFE']->type,
                    'fileTarget' => $target,
                    'title' => $title,
                    'ATagParams' => $this->getATagParams($conf),
                    'additionalParams' => '&jumpurl=' . rawurlencode($theFileEnc) . $this->locDataJU($theFileEnc, $conf['jumpurl.']['secure.']) . $GLOBALS['TSFE']->getMethodUrlIdToken
                );
            } else {
                $typoLinkConf = array(
                    'parameter' => $theFileEnc,
                    'fileTarget' => $target,
                    'title' => $title,
                    'ATagParams' => $this->getATagParams($conf)
                );
            }
            // If the global jumpURL feature is activated, but is disabled for this
            // filelink, the global parameter needs to be disabled as well for this link creation
            $globalJumpUrlEnabled = $GLOBALS['TSFE']->config['config']['jumpurl_enable'];
            if ($globalJumpUrlEnabled && isset($conf['jumpurl']) && $conf['jumpurl'] == 0) {
                $GLOBALS['TSFE']->config['config']['jumpurl_enable'] = 0;
            } elseif (!$globalJumpUrlEnabled && $conf['jumpurl']) {
                $GLOBALS['TSFE']->config['config']['jumpurl_enable'] = 1;
            }
            $theLinkWrap = $this->typoLink('|', $typoLinkConf);
            // Now the original value is set again
            $GLOBALS['TSFE']->config['config']['jumpurl_enable'] = $globalJumpUrlEnabled;
            $theSize = filesize($theFile);
            $fI = GeneralUtility::split_fileref($theFile);
            if ($conf['icon']) {
                $conf['icon.']['path'] = isset($conf['icon.']['path.']) ? $this->stdWrap($conf['icon.']['path'], $conf['icon.']['path.']) : $conf['icon.']['path'];
                $iconP = !empty($conf['icon.']['path']) ? $conf['icon.']['path'] : TYPO3_mainDir . '/gfx/fileicons/';
                $conf['icon.']['ext'] = isset($conf['icon.']['ext.']) ? $this->stdWrap($conf['icon.']['ext'], $conf['icon.']['ext.']) : $conf['icon.']['ext'];
                $iconExt = !empty($conf['icon.']['ext']) ? '.' . $conf['icon.']['ext'] : '.gif';
                $icon = @is_file(($iconP . $fI['fileext'] . $iconExt)) ? $iconP . $fI['fileext'] . $iconExt : $iconP . 'default' . $iconExt;
                // Checking for images: If image, then return link to thumbnail.
                $IEList = isset($conf['icon_image_ext_list.']) ? $this->stdWrap($conf['icon_image_ext_list'], $conf['icon_image_ext_list.']) : $conf['icon_image_ext_list'];
                $image_ext_list = str_replace(' ', '', strtolower($IEList));
                if ($fI['fileext'] && GeneralUtility::inList($image_ext_list, $fI['fileext'])) {
                    if ($conf['iconCObject']) {
                        $icon = $this->cObjGetSingle($conf['iconCObject'], $conf['iconCObject.'], 'iconCObject');
                    } else {
                        if ($GLOBALS['TYPO3_CONF_VARS']['GFX']['thumbnails']) {
                            $thumbSize = '';
                            if ($conf['icon_thumbSize'] || $conf['icon_thumbSize.']) {
                                $thumbSize = '&size=' . (isset($conf['icon_thumbSize.']) ? $this->stdWrap($conf['icon_thumbSize'], $conf['icon_thumbSize.']) : $conf['icon_thumbSize']);
                            }
                            $check = basename($theFile) . ':' . filemtime($theFile) . ':' . $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'];
                            $md5sum = '&md5sum=' . md5($check);
                            $icon = 'typo3/thumbs.php?file=' . rawurlencode(('../' . $theFile)) . $thumbSize . $md5sum;
                        } else {
                            $icon = TYPO3_mainDir . 'gfx/fileicons/notfound_thumb.gif';
                        }
                        $icon = '<img src="' . htmlspecialchars(($GLOBALS['TSFE']->absRefPrefix . $icon)) . '"' . $this->getBorderAttr(' border="0"') . $this->getAltParam($conf) . ' />';
                    }
                } else {
                    $conf['icon.']['widthAttribute'] = isset($conf['icon.']['widthAttribute.']) ? $this->stdWrap($conf['icon.']['widthAttribute'], $conf['icon.']['widthAttribute.']) : $conf['icon.']['widthAttribute'];
                    $iconWidth = !empty($conf['icon.']['widthAttribute']) ? $conf['icon.']['widthAttribute'] : 18;
                    $conf['icon.']['heightAttribute'] = isset($conf['icon.']['heightAttribute.']) ? $this->stdWrap($conf['icon.']['heightAttribute'], $conf['icon.']['heightAttribute.']) : $conf['icon.']['heightAttribute'];
                    $iconHeight = !empty($conf['icon.']['heightAttribute']) ? $conf['icon.']['heightAttribute'] : 16;
                    $icon = '<img src="' . htmlspecialchars(($GLOBALS['TSFE']->absRefPrefix . $icon)) . '" width="' . $iconWidth . '" height="' . $iconHeight . '"' . $this->getBorderAttr(' border="0"') . $this->getAltParam($conf) . ' />';
                }
                if ($conf['icon_link'] && !$conf['combinedLink']) {
                    $icon = $this->wrap($icon, $theLinkWrap);
                }
                $icon = isset($conf['icon.']) ? $this->stdWrap($icon, $conf['icon.']) : $icon;
            }
            if ($conf['size']) {
                $size = isset($conf['size.']) ? $this->stdWrap($theSize, $conf['size.']) : $theSize;
            }
            // Wrapping file label
            if ($conf['removePrependedNumbers']) {
                $theValue = preg_replace('/_[0-9][0-9](\\.[[:alnum:]]*)$/', '\\1', $theValue);
            }
            if (isset($conf['labelStdWrap.'])) {
                $theValue = $this->stdWrap($theValue, $conf['labelStdWrap.']);
            }
            // Wrapping file
            $wrap = isset($conf['wrap.']) ? $this->stdWrap($conf['wrap'], $conf['wrap.']) : $conf['wrap'];
            if ($conf['combinedLink']) {
                $theValue = $icon . $theValue;
                if ($conf['ATagBeforeWrap']) {
                    $theValue = $this->wrap($this->wrap($theValue, $wrap), $theLinkWrap);
                } else {
                    $theValue = $this->wrap($this->wrap($theValue, $theLinkWrap), $wrap);
                }
                $file = isset($conf['file.']) ? $this->stdWrap($theValue, $conf['file.']) : $theValue;
                // output
                $output = $file . $size;
            } else {
                if ($conf['ATagBeforeWrap']) {
                    $theValue = $this->wrap($this->wrap($theValue, $wrap), $theLinkWrap);
                } else {
                    $theValue = $this->wrap($this->wrap($theValue, $theLinkWrap), $wrap);
                }
                $file = isset($conf['file.']) ? $this->stdWrap($theValue, $conf['file.']) : $theValue;
                // output
                $output = $icon . $file . $size;
            }
            if (isset($conf['stdWrap.'])) {
                $output = $this->stdWrap($output, $conf['stdWrap.']);
            }
            return $output;
        }
    }

    public function locDataJU($jumpUrl, $conf) {
        $fI = pathinfo($jumpUrl);
        $mimetype = '';
        $mimetypeValue = '';
        if ($fI['extension']) {
            $mimeTypes = GeneralUtility::trimExplode(',', $conf['mimeTypes'], TRUE);
            foreach ($mimeTypes as $v) {
                $parts = explode('=', $v, 2);
                if (strtolower($fI['extension']) == strtolower(trim($parts[0]))) {
                    $mimetypeValue = trim($parts[1]);
                    $mimetype = '&mimeType=' . rawurlencode($mimetypeValue);
                    break;
                }
            }
        }
        $locationData = $GLOBALS['TSFE']->id . ':' . $this->currentRecord;
        $rec = '&locationData=' . rawurlencode($locationData);
        $hArr = array(
            $jumpUrl,
            $locationData,
            $mimetypeValue
        );
        $juHash = '&juHash=' . GeneralUtility::hmac(serialize($hArr));
        return '&juSecure=1' . $mimetype . $rec . $juHash;
    }

    public function calc($val) {
        $parts = GeneralUtility::splitCalc($val, '+-*/');
        $value = 0;
        foreach ($parts as $part) {
            $theVal = $part[1];
            $sign = $part[0];
            if ((string) (int)$theVal === (string) $theVal) {
                $theVal = (int)$theVal;
            } else {
                $theVal = 0;
            }
            if ($sign == '-') {
                $value -= $theVal;
            }
            if ($sign == '+') {
                $value += $theVal;
            }
            if ($sign == '/') {
                if ((int)$theVal) {
                    $value /= (int)$theVal;
                }
            }
            if ($sign == '*') {
                $value *= $theVal;
            }
        }
        return $value;
    }

    public function calcIntExplode($delim, $string) {
        $temp = explode($delim, $string);
        foreach ($temp as $key => $val) {
            $temp[$key] = (int)$this->calc($val);
        }
        return $temp;
    }

    public function splitObj($value, $conf) {
        $conf['token'] = isset($conf['token.']) ? $this->stdWrap($conf['token'], $conf['token.']) : $conf['token'];
        if ($conf['token'] === '') {
            return $value;
        }
        $conf['max'] = isset($conf['max.']) ? (int)$this->stdWrap($conf['max'], $conf['max.']) : (int)$conf['max'];
        $conf['min'] = isset($conf['min.']) ? (int)$this->stdWrap($conf['min'], $conf['min.']) : (int)$conf['min'];
        $valArr = explode($conf['token'], $value);
        if (count($valArr) && (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($conf['returnKey']) || $conf['returnKey.'])) {
            $key = isset($conf['returnKey.']) ? (int)$this->stdWrap($conf['returnKey'], $conf['returnKey.']) : (int)$conf['returnKey'];
            $content = isset($valArr[$key]) ? $valArr[$key] : '';
        } else {
            // calculate splitCount
            $splitCount = count($valArr);
            $max = isset($conf['max.']) ? $this->stdWrap($conf['max'], $conf['max.']) : $conf['max'];
            if ($max && $splitCount > $max) {
                $splitCount = $max;
            }
            $min = isset($conf['min.']) ? $this->stdWrap($conf['min'], $conf['min.']) : $conf['min'];
            if ($min && $splitCount < $min) {
                $splitCount = $min;
            }
            $wrap = isset($conf['wrap.']) ? $this->stdWrap($conf['wrap'], $conf['wrap.']) : $conf['wrap'];
            $cObjNum = isset($conf['cObjNum.']) ? $this->stdWrap($conf['cObjNum'], $conf['cObjNum.']) : $conf['cObjNum'];
            if ($wrap || $cObjNum) {
                $splitArr = array();
                $splitArr['wrap'] = $wrap;
                $splitArr['cObjNum'] = $cObjNum;
                $splitArr = $GLOBALS['TSFE']->tmpl->splitConfArray($splitArr, $splitCount);
            }
            $content = '';
            for ($a = 0; $a < $splitCount; $a++) {
                $GLOBALS['TSFE']->register['SPLIT_COUNT'] = $a;
                $value = '' . $valArr[$a];
                $this->data[$this->currentValKey] = $value;
                if ($splitArr[$a]['cObjNum']) {
                    $objName = (int)$splitArr[$a]['cObjNum'];
                    $value = isset($conf[$objName . '.']) ? $this->stdWrap($this->cObjGet($conf[$objName . '.'], $objName . '.'), $conf[$objName . '.']) : $this->cObjGet($conf[$objName . '.'], $objName . '.');
                }
                $wrap = isset($splitArr[$a]['wrap.']) ? $this->stdWrap($splitArr[$a]['wrap'], $splitArr[$a]['wrap.']) : $splitArr[$a]['wrap'];
                if ($wrap) {
                    $value = $this->wrap($value, $wrap);
                }
                $content .= $value;
            }
        }
        return $content;
    }

    protected function replacement($content, array $configuration) {
        // Sorts actions in configuration by numeric index
        ksort($configuration, SORT_NUMERIC);
        foreach ($configuration as $index => $action) {
            // Checks whether we have an valid action and a numeric key ending with a dot ("10.")
            if (is_array($action) && substr($index, -1) === '.' && \TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger(substr($index, 0, -1))) {
                $content = $this->replacementSingle($content, $action);
            }
        }
        return $content;
    }

    protected function replacementSingle($content, array $configuration) {
        if ((isset($configuration['search']) || isset($configuration['search.'])) && (isset($configuration['replace']) || isset($configuration['replace.']))) {
            // Gets the strings
            $search = isset($configuration['search.']) ? $this->stdWrap($configuration['search'], $configuration['search.']) : $configuration['search'];
            $replace = isset($configuration['replace.']) ? $this->stdWrap($configuration['replace'], $configuration['replace.']) : $configuration['replace'];
            // Determines whether regular expression shall be used
            if (isset($configuration['useRegExp']) || $configuration['useRegExp.']) {
                $useRegularExpression = isset($configuration['useRegExp.']) ? $this->stdWrap($configuration['useRegExp'], $configuration['useRegExp.']) : $configuration['useRegExp'];
            }
            // Determines whether replace-pattern uses option-split
            if (isset($configuration['useOptionSplitReplace']) || isset($configuration['useOptionSplitReplace.'])) {
                $useOptionSplitReplace = isset($configuration['useOptionSplitReplace.']) ? $this->stdWrap($configuration['useOptionSplitReplace'], $configuration['useOptionSplitReplace.']) : $configuration['useOptionSplitReplace'];
            }

            // Performs a replacement by preg_replace()
            if (isset($useRegularExpression)) {
                // Get separator-character which precedes the string and separates search-string from the modifiers
                $separator = $search[0];
                $startModifiers = strrpos($search, $separator);
                if ($separator !== FALSE && $startModifiers > 0) {
                    $modifiers = substr($search, $startModifiers + 1);
                    // remove "e" (eval-modifier), which would otherwise allow to run arbitrary PHP-code
                    $modifiers = str_replace('e', '', $modifiers);
                    $search = substr($search, 0, ($startModifiers + 1)) . $modifiers;
                }
                if (empty($useOptionSplitReplace)) {
                    $content = preg_replace($search, $replace, $content);
                } else {
                    // init for replacement
                    $splitCount = preg_match_all($search, $content, $matches);
                    $replaceArray = $GLOBALS['TSFE']->tmpl->splitConfArray(array($replace), $splitCount);
                    $replaceCount = 0;

                    $replaceCallback = function($match) use ($replaceArray, $search, &$replaceCount) {
                        $replaceCount++;
                        return preg_replace($search, $replaceArray[$replaceCount - 1][0], $match[0]);
                    };
                    $content = preg_replace_callback($search, $replaceCallback, $content);
                }
            } else {
                if (empty($useOptionSplitReplace)) {
                    $content = str_replace($search, $replace, $content);
                } else {
                    // turn search-string into a preg-pattern
                    $searchPreg = '#' . preg_quote($search, '#') . '#';

                    // init for replacement
                    $splitCount = preg_match_all($searchPreg, $content, $matches);
                    $replaceArray = $GLOBALS['TSFE']->tmpl->splitConfArray(array($replace), $splitCount);
                    $replaceCount = 0;

                    $replaceCallback = function($match) use ($replaceArray, $search, &$replaceCount) {
                        $replaceCount++;
                        return $replaceArray[$replaceCount - 1][0];
                    };
                    $content = preg_replace_callback($searchPreg, $replaceCallback, $content);
                }
            }
        }
        return $content;
    }

    protected function round($content, array $conf = array()) {
        $decimals = isset($conf['decimals.']) ? $this->stdWrap($conf['decimals'], $conf['decimals.']) : $conf['decimals'];
        $type = isset($conf['roundType.']) ? $this->stdWrap($conf['roundType'], $conf['roundType.']) : $conf['roundType'];
        $floatVal = floatval($content);
        switch ($type) {
            case 'ceil':
                $content = ceil($floatVal);
                break;
            case 'floor':
                $content = floor($floatVal);
                break;
            case 'round':

            default:
                $content = round($floatVal, (int)$decimals);
        }
        return $content;
    }

    public function numberFormat($content, $conf) {
        $decimals = isset($conf['decimals.']) ? $this->stdWrap($conf['decimals'], $conf['decimals.']) : $conf['decimals'];
        $dec_point = isset($conf['dec_point.']) ? $this->stdWrap($conf['dec_point'], $conf['dec_point.']) : $conf['dec_point'];
        $thousands_sep = isset($conf['thousands_sep.']) ? $this->stdWrap($conf['thousands_sep'], $conf['thousands_sep.']) : $conf['thousands_sep'];
        return number_format(floatval($content), $decimals, $dec_point, $thousands_sep);
    }

    public function parseFunc($theValue, $conf, $ref = '') {
        // Fetch / merge reference, if any
        if ($ref) {
            $temp_conf = array(
                'parseFunc' => $ref,
                'parseFunc.' => $conf
            );
            $temp_conf = $this->mergeTSRef($temp_conf, 'parseFunc');
            $conf = $temp_conf['parseFunc.'];
        }
        // Process:
        if ((string)$conf['externalBlocks'] !== '') {
            $tags = strtolower(implode(',', GeneralUtility::trimExplode(',', $conf['externalBlocks'])));
            $htmlParser = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Html\\HtmlParser');
            $parts = $htmlParser->splitIntoBlock($tags, $theValue);
            foreach ($parts as $k => $v) {
                if ($k % 2) {
                    // font:
                    $tagName = strtolower($htmlParser->getFirstTagName($v));
                    $cfg = $conf['externalBlocks.'][$tagName . '.'];
                    if ($cfg['stripNLprev'] || $cfg['stripNL']) {
                        $parts[$k - 1] = preg_replace('/' . CR . '?' . LF . '[ ]*$/', '', $parts[$k - 1]);
                    }
                    if ($cfg['stripNLnext'] || $cfg['stripNL']) {
                        $parts[$k + 1] = preg_replace('/^[ ]*' . CR . '?' . LF . '/', '', $parts[$k + 1]);
                    }
                }
            }
            foreach ($parts as $k => $v) {
                if ($k % 2) {
                    $tag = $htmlParser->getFirstTag($v);
                    $tagName = strtolower($htmlParser->getFirstTagName($v));
                    $cfg = $conf['externalBlocks.'][$tagName . '.'];
                    if ($cfg['callRecursive']) {
                        $parts[$k] = $this->parseFunc($htmlParser->removeFirstAndLastTag($v), $conf);
                        if (!$cfg['callRecursive.']['dontWrapSelf']) {
                            if ($cfg['callRecursive.']['alternativeWrap']) {
                                $parts[$k] = $this->wrap($parts[$k], $cfg['callRecursive.']['alternativeWrap']);
                            } else {
                                if (is_array($cfg['callRecursive.']['tagStdWrap.'])) {
                                    $tag = $this->stdWrap($tag, $cfg['callRecursive.']['tagStdWrap.']);
                                }
                                $parts[$k] = $tag . $parts[$k] . '</' . $tagName . '>';
                            }
                        }
                    } elseif ($cfg['HTMLtableCells']) {
                        $rowParts = $htmlParser->splitIntoBlock('tr', $parts[$k]);
                        foreach ($rowParts as $kk => $vv) {
                            if ($kk % 2) {
                                $colParts = $htmlParser->splitIntoBlock('td,th', $vv);
                                $cc = 0;
                                foreach ($colParts as $kkk => $vvv) {
                                    if ($kkk % 2) {
                                        $cc++;
                                        $tag = $htmlParser->getFirstTag($vvv);
                                        $tagName = strtolower($htmlParser->getFirstTagName($vvv));
                                        $colParts[$kkk] = $htmlParser->removeFirstAndLastTag($vvv);
                                        if ($cfg['HTMLtableCells.'][$cc . '.']['callRecursive'] || !isset($cfg['HTMLtableCells.'][($cc . '.')]['callRecursive']) && $cfg['HTMLtableCells.']['default.']['callRecursive']) {
                                            if ($cfg['HTMLtableCells.']['addChr10BetweenParagraphs']) {
                                                $colParts[$kkk] = str_replace('</p><p>', '</p>' . LF . '<p>', $colParts[$kkk]);
                                            }
                                            $colParts[$kkk] = $this->parseFunc($colParts[$kkk], $conf);
                                        }
                                        $tagStdWrap = is_array($cfg['HTMLtableCells.'][$cc . '.']['tagStdWrap.']) ? $cfg['HTMLtableCells.'][$cc . '.']['tagStdWrap.'] : $cfg['HTMLtableCells.']['default.']['tagStdWrap.'];
                                        if (is_array($tagStdWrap)) {
                                            $tag = $this->stdWrap($tag, $tagStdWrap);
                                        }
                                        $stdWrap = is_array($cfg['HTMLtableCells.'][$cc . '.']['stdWrap.']) ? $cfg['HTMLtableCells.'][$cc . '.']['stdWrap.'] : $cfg['HTMLtableCells.']['default.']['stdWrap.'];
                                        if (is_array($stdWrap)) {
                                            $colParts[$kkk] = $this->stdWrap($colParts[$kkk], $stdWrap);
                                        }
                                        $colParts[$kkk] = $tag . $colParts[$kkk] . '</' . $tagName . '>';
                                    }
                                }
                                $rowParts[$kk] = implode('', $colParts);
                            }
                        }
                        $parts[$k] = implode('', $rowParts);
                    }
                    if (is_array($cfg['stdWrap.'])) {
                        $parts[$k] = $this->stdWrap($parts[$k], $cfg['stdWrap.']);
                    }
                } else {
                    $parts[$k] = $this->_parseFunc($parts[$k], $conf);
                }
            }
            return implode('', $parts);
        } else {
            return $this->_parseFunc($theValue, $conf);
        }
    }

    public function _parseFunc($theValue, $conf) {
        if (!empty($conf['if.']) && !$this->checkIf($conf['if.'])) {
            return $theValue;
        }
        // Indicates that the data is from within a tag.
        $inside = 0;
        // Pointer to the total string position
        $pointer = 0;
        // Loaded with the current typo-tag if any.
        $currentTag = '';
        $stripNL = 0;
        $contentAccum = array();
        $contentAccumP = 0;
        $allowTags = strtolower(str_replace(' ', '', $conf['allowTags']));
        $denyTags = strtolower(str_replace(' ', '', $conf['denyTags']));
        $totalLen = strlen($theValue);
        do {
            if (!$inside) {
                if (!is_array($currentTag)) {
                    // These operations should only be performed on code outside the typotags...
                    // data: this checks that we enter tags ONLY if the first char in the tag is alphanumeric OR '/'
                    $len_p = 0;
                    $c = 100;
                    do {
                        $len = strcspn(substr($theValue, $pointer + $len_p), '<');
                        $len_p += $len + 1;
                        $endChar = ord(strtolower(substr($theValue, $pointer + $len_p, 1)));
                        $c--;
                    } while ($c > 0 && $endChar && ($endChar < 97 || $endChar > 122) && $endChar != 47);
                    $len = $len_p - 1;
                } else {
                    // If we're inside a currentTag, just take it to the end of that tag!
                    $tempContent = strtolower(substr($theValue, $pointer));
                    $len = strpos($tempContent, '</' . $currentTag[0]);
                    if (is_string($len) && !$len) {
                        $len = strlen($tempContent);
                    }
                }
                // $data is the content until the next <tag-start or end is detected.
                // In case of a currentTag set, this would mean all data between the start- and end-tags
                $data = substr($theValue, $pointer, $len);
                if ($data != '') {
                    if ($stripNL) {
                        // If the previous tag was set to strip NewLines in the beginning of the next data-chunk.
                        $data = preg_replace('/^[ ]*' . CR . '?' . LF . '/', '', $data);
                    }
                    // These operations should only be performed on code outside the tags...
                    if (!is_array($currentTag)) {
                        // Constants
                        $tmpConstants = $GLOBALS['TSFE']->tmpl->setup['constants.'];
                        if ($conf['constants'] && is_array($tmpConstants)) {
                            foreach ($tmpConstants as $key => $val) {
                                if (is_string($val)) {
                                    $data = str_replace('###' . $key . '###', $val, $data);
                                }
                            }
                        }
                        // Short
                        if (is_array($conf['short.'])) {
                            $shortWords = $conf['short.'];
                            krsort($shortWords);
                            foreach ($shortWords as $key => $val) {
                                if (is_string($val)) {
                                    $data = str_replace($key, $val, $data);
                                }
                            }
                        }
                        // stdWrap
                        if (is_array($conf['plainTextStdWrap.'])) {
                            $data = $this->stdWrap($data, $conf['plainTextStdWrap.']);
                        }
                        // userFunc
                        if ($conf['userFunc']) {
                            $data = $this->callUserFunction($conf['userFunc'], $conf['userFunc.'], $data);
                        }
                        // Makelinks: (Before search-words as we need the links to be generated when searchwords go on...!)
                        if ($conf['makelinks']) {
                            $data = $this->http_makelinks($data, $conf['makelinks.']['http.']);
                            $data = $this->mailto_makelinks($data, $conf['makelinks.']['mailto.']);
                        }
                        // Search Words:
                        if ($GLOBALS['TSFE']->no_cache && $conf['sword'] && is_array($GLOBALS['TSFE']->sWordList) && $GLOBALS['TSFE']->sWordRegEx) {
                            $newstring = '';
                            do {
                                $pregSplitMode = 'i';
                                if (isset($GLOBALS['TSFE']->config['config']['sword_noMixedCase']) && !empty($GLOBALS['TSFE']->config['config']['sword_noMixedCase'])) {
                                    $pregSplitMode = '';
                                }
                                $pieces = preg_split('/' . $GLOBALS['TSFE']->sWordRegEx . '/' . $pregSplitMode, $data, 2);
                                $newstring .= $pieces[0];
                                $match_len = strlen($data) - (strlen($pieces[0]) + strlen($pieces[1]));
                                if (strstr($pieces[0], '<') || strstr($pieces[0], '>')) {
                                    // Returns TRUE, if a '<' is closer to the string-end than '>'.
                                    // This is the case if we're INSIDE a tag (that could have been
                                    // made by makelinks...) and we must secure, that the inside of a tag is
                                    // not marked up.
                                    $inTag = strrpos($pieces[0], '<') > strrpos($pieces[0], '>');
                                }
                                // The searchword:
                                $match = substr($data, strlen($pieces[0]), $match_len);
                                if (trim($match) && strlen($match) > 1 && !$inTag) {
                                    $match = $this->wrap($match, $conf['sword']);
                                }
                                // Concatenate the Search Word again.
                                $newstring .= $match;
                                $data = $pieces[1];
                            } while ($pieces[1]);
                            $data = $newstring;
                        }
                    }
                    $contentAccum[$contentAccumP] .= $data;
                }
                $inside = 1;
            } else {
                // tags
                $len = strcspn(substr($theValue, $pointer), '>') + 1;
                $data = substr($theValue, $pointer, $len);
                if (StringUtility::isLastPartOfString($data, '/>') && !GeneralUtility::isFirstPartOfStr($data, '<link ')) {
                    $tagContent = substr($data, 1, -2);
                } else {
                    $tagContent = substr($data, 1, -1);
                }
                $tag = explode(' ', trim($tagContent), 2);
                $tag[0] = strtolower($tag[0]);
                if ($tag[0][0] === '/') {
                    $tag[0] = substr($tag[0], 1);
                    $tag['out'] = 1;
                }
                if ($conf['tags.'][$tag[0]]) {
                    $treated = 0;
                    $stripNL = 0;
                    // in-tag
                    if (!$currentTag && !$tag['out']) {
                        // $currentTag (array!) is the tag we are currently processing
                        $currentTag = $tag;
                        $contentAccumP++;
                        $treated = 1;
                        // in-out-tag: img and other empty tags
                        if (preg_match('/^(area|base|br|col|hr|img|input|meta|param)$/i', $tag[0])) {
                            $tag['out'] = 1;
                        }
                    }
                    // out-tag
                    if ($currentTag[0] == $tag[0] && $tag['out']) {
                        $theName = $conf['tags.'][$tag[0]];
                        $theConf = $conf['tags.'][$tag[0] . '.'];
                        // This flag indicates, that NL- (13-10-chars) should be stripped first and last.
                        $stripNL = $theConf['stripNL'] ? 1 : 0;
                        // This flag indicates, that this TypoTag section should NOT be included in the nonTypoTag content.
                        $breakOut = $theConf['breakoutTypoTagContent'] ? 1 : 0;
                        $this->parameters = array();
                        if ($currentTag[1]) {
                            $params = GeneralUtility::get_tag_attributes($currentTag[1]);
                            if (is_array($params)) {
                                foreach ($params as $option => $val) {
                                    $this->parameters[strtolower($option)] = $val;
                                }
                            }
                        }
                        $this->parameters['allParams'] = trim($currentTag[1]);
                        // Removes NL in the beginning and end of the tag-content AND at the end of the currentTagBuffer.
                        // $stripNL depends on the configuration of the current tag
                        if ($stripNL) {
                            $contentAccum[$contentAccumP - 1] = preg_replace('/' . CR . '?' . LF . '[ ]*$/', '', $contentAccum[$contentAccumP - 1]);
                            $contentAccum[$contentAccumP] = preg_replace('/^[ ]*' . CR . '?' . LF . '/', '', $contentAccum[$contentAccumP]);
                            $contentAccum[$contentAccumP] = preg_replace('/' . CR . '?' . LF . '[ ]*$/', '', $contentAccum[$contentAccumP]);
                        }
                        $this->data[$this->currentValKey] = $contentAccum[$contentAccumP];
                        $newInput = $this->cObjGetSingle($theName, $theConf, '/parseFunc/.tags.' . $tag[0]);
                        // fetch the content object
                        $contentAccum[$contentAccumP] = $newInput;
                        $contentAccumP++;
                        // If the TypoTag section
                        if (!$breakOut) {
                            $contentAccum[$contentAccumP - 2] .= $contentAccum[($contentAccumP - 1)] . $contentAccum[$contentAccumP];
                            unset($contentAccum[$contentAccumP]);
                            unset($contentAccum[$contentAccumP - 1]);
                            $contentAccumP -= 2;
                        }
                        unset($currentTag);
                        $treated = 1;
                    }
                    // other tags...
                    if (!$treated) {
                        $contentAccum[$contentAccumP] .= $data;
                    }
                } else {
                    // If a tag was not a typo tag, then it is just added to the content
                    $stripNL = 0;
                    if (GeneralUtility::inList($allowTags, $tag[0]) || $denyTags != '*' && !GeneralUtility::inList($denyTags, $tag[0])) {
                        $contentAccum[$contentAccumP] .= $data;
                    } else {
                        $contentAccum[$contentAccumP] .= HTMLSpecialChars($data);
                    }
                }
                $inside = 0;
            }
            $pointer += $len;
        } while ($pointer < $totalLen);
        // Parsing nonTypoTag content (all even keys):
        reset($contentAccum);
        $contentAccumCount = count($contentAccum);
        for ($a = 0; $a < $contentAccumCount; $a++) {
            if ($a % 2 != 1) {
                // stdWrap
                if (is_array($conf['nonTypoTagStdWrap.'])) {
                    $contentAccum[$a] = $this->stdWrap($contentAccum[$a], $conf['nonTypoTagStdWrap.']);
                }
                // userFunc
                if ($conf['nonTypoTagUserFunc']) {
                    $contentAccum[$a] = $this->callUserFunction($conf['nonTypoTagUserFunc'], $conf['nonTypoTagUserFunc.'], $contentAccum[$a]);
                }
            }
        }
        return implode('', $contentAccum);
    }

    public function encaps_lineSplit($theValue, $conf) {
        $lParts = explode(LF, $theValue);
        $encapTags = GeneralUtility::trimExplode(',', strtolower($conf['encapsTagList']), TRUE);
        $nonWrappedTag = $conf['nonWrappedTag'];
        $defaultAlign = isset($conf['defaultAlign.']) ? trim($this->stdWrap($conf['defaultAlign'], $conf['defaultAlign.'])) : trim($conf['defaultAlign']);
        if ((string)$theValue === '') {
            return '';
        }
        foreach ($lParts as $k => $l) {
            $sameBeginEnd = 0;
            $emptyTag = 0;
            $l = trim($l);
            $attrib = array();
            $nWrapped = 0;
            if ($l[0] === '<' && substr($l, -1) === '>') {
                $fwParts = explode('>', substr($l, 1), 2);
                list($tagName, $tagParams) = explode(' ', $fwParts[0], 2);
                if (!$fwParts[1]) {
                    if (substr($tagName, -1) == '/') {
                        $tagName = substr($tagName, 0, -1);
                    }
                    if (substr($fwParts[0], -1) == '/') {
                        $sameBeginEnd = 1;
                        $emptyTag = 1;
                        $attrib = GeneralUtility::get_tag_attributes('<' . substr($fwParts[0], 0, -1) . '>');
                    }
                } else {
                    $backParts = GeneralUtility::revExplode('<', substr($fwParts[1], 0, -1), 2);
                    $attrib = GeneralUtility::get_tag_attributes('<' . $fwParts[0] . '>');
                    $str_content = $backParts[0];
                    $sameBeginEnd = substr(strtolower($backParts[1]), 1, strlen($tagName)) == strtolower($tagName);
                }
            }
            if ($sameBeginEnd && in_array(strtolower($tagName), $encapTags)) {
                $uTagName = strtoupper($tagName);
                $uTagName = strtoupper($conf['remapTag.'][$uTagName] ? $conf['remapTag.'][$uTagName] : $uTagName);
            } else {
                $uTagName = strtoupper($nonWrappedTag);
                // The line will be wrapped: $uTagName should not be an empty tag
                $emptyTag = 0;
                $str_content = $lParts[$k];
                $nWrapped = 1;
                $attrib = array();
            }
            // Wrapping all inner-content:
            if (is_array($conf['innerStdWrap_all.'])) {
                $str_content = $this->stdWrap($str_content, $conf['innerStdWrap_all.']);
            }
            if ($uTagName) {
                // Setting common attributes
                if (is_array($conf['addAttributes.'][$uTagName . '.'])) {
                    foreach ($conf['addAttributes.'][$uTagName . '.'] as $kk => $vv) {
                        if (!is_array($vv)) {
                            if ((string) $conf['addAttributes.'][($uTagName . '.')][($kk . '.')]['setOnly'] == 'blank') {
                                if ((string)$attrib[$kk] === '') {
                                    $attrib[$kk] = $vv;
                                }
                            } elseif ((string) $conf['addAttributes.'][($uTagName . '.')][($kk . '.')]['setOnly'] == 'exists') {
                                if (!isset($attrib[$kk])) {
                                    $attrib[$kk] = $vv;
                                }
                            } else {
                                $attrib[$kk] = $vv;
                            }
                        }
                    }
                }
                // Wrapping all inner-content:
                if (is_array($conf['encapsLinesStdWrap.'][$uTagName . '.'])) {
                    $str_content = $this->stdWrap($str_content, $conf['encapsLinesStdWrap.'][$uTagName . '.']);
                }
                // Default align
                if (!$attrib['align'] && $defaultAlign) {
                    $attrib['align'] = $defaultAlign;
                }
                $params = GeneralUtility::implodeAttributes($attrib, 1);
                if ($conf['removeWrapping'] && !($emptyTag && $conf['removeWrapping.']['keepSingleTag'])) {
                    $str_content = $str_content;
                } else {
                    if ($emptyTag) {
                        $str_content = '<' . strtolower($uTagName) . (trim($params) ? ' ' . trim($params) : '') . ' />';
                    } else {
                        $str_content = '<' . strtolower($uTagName) . (trim($params) ? ' ' . trim($params) : '') . '>' . $str_content . '</' . strtolower($uTagName) . '>';
                    }
                }
            }
            if ($nWrapped && $conf['wrapNonWrappedLines']) {
                $str_content = $this->wrap($str_content, $conf['wrapNonWrappedLines']);
            }
            $lParts[$k] = $str_content;
        }
        return implode(LF, $lParts);
    }

    public function http_makelinks($data, $conf) {
        $aTagParams = $this->getATagParams($conf);
        $schemes = array('http://', 'https://');
        foreach ($schemes as $scheme) {
            $textpieces = explode($scheme, $data);
            $pieces = count($textpieces);
            $textstr = $textpieces[0];
            $initP = '?id=' . $GLOBALS['TSFE']->id . '&type=' . $GLOBALS['TSFE']->type;
            for ($i = 1; $i < $pieces; $i++) {
                $len = strcspn($textpieces[$i], chr(32) . TAB . CRLF);
                if (trim(substr($textstr, -1)) == '' && $len) {
                    $lastChar = substr($textpieces[$i], $len - 1, 1);
                    if (!preg_match('/[A-Za-z0-9\\/#_-]/', $lastChar)) {
                        $len--;
                    }
                    // Included '\/' 3/12
                    $parts[0] = substr($textpieces[$i], 0, $len);
                    $parts[1] = substr($textpieces[$i], $len);
                    $keep = $conf['keep'];
                    $linkParts = parse_url($scheme . $parts[0]);
                    $linktxt = '';
                    if (strstr($keep, 'scheme')) {
                        $linktxt = $scheme;
                    }
                    $linktxt .= $linkParts['host'];
                    if (strstr($keep, 'path')) {
                        $linktxt .= $linkParts['path'];
                        // Added $linkParts['query'] 3/12
                        if (strstr($keep, 'query') && $linkParts['query']) {
                            $linktxt .= '?' . $linkParts['query'];
                        } elseif ($linkParts['path'] == '/') {
                            $linktxt = substr($linktxt, 0, -1);
                        }
                    }
                    if (isset($conf['extTarget'])) {
                        if (isset($conf['extTarget.'])) {
                            $target = $this->stdWrap($conf['extTarget'], $conf['extTarget.']);
                        } else {
                            $target = $conf['extTarget'];
                        }
                    } else {
                        $target = $GLOBALS['TSFE']->extTarget;
                    }
                    if ($GLOBALS['TSFE']->config['config']['jumpurl_enable']) {
                        $jumpurl = 'http://' . $parts[0];
                        $juHash = GeneralUtility::hmac($jumpurl, 'jumpurl');
                        $res = '<a' . ' href="' . htmlspecialchars(($GLOBALS['TSFE']->absRefPrefix . $GLOBALS['TSFE']->config['mainScript'] . $initP . '&jumpurl=' . rawurlencode($jumpurl))) . '&juHash=' . $juHash . $GLOBALS['TSFE']->getMethodUrlIdToken . '"' . ($target ? ' target="' . htmlspecialchars($target) . '"' : '') . $aTagParams . $this->extLinkATagParams(('http://' . $parts[0]), 'url') . '>';
                    } else {
                        $res = '<a' . ' href="' . $scheme . htmlspecialchars($parts[0]) . '"' . ($target ? ' target="' . htmlspecialchars($target) . '"' : '') . $aTagParams . $this->extLinkATagParams(('http://' . $parts[0]), 'url') . '>';
                    }
                    $wrap = isset($conf['wrap.']) ? $this->stdWrap($conf['wrap'], $conf['wrap.']) : $conf['wrap'];
                    if ($conf['ATagBeforeWrap']) {
                        $res = $res . $this->wrap($linktxt, $wrap) . '</a>';
                    } else {
                        $res = $this->wrap($res . $linktxt . '</a>', $wrap);
                    }
                    $textstr .= $res . $parts[1];
                } else {
                    $textstr .= $scheme . $textpieces[$i];
                }
            }
            $data = $textstr;
        }
        return $textstr;
    }

    public function mailto_makelinks($data, $conf) {
        // http-split
        $aTagParams = $this->getATagParams($conf);
        $textpieces = explode('mailto:', $data);
        $pieces = count($textpieces);
        $textstr = $textpieces[0];
        $initP = '?id=' . $GLOBALS['TSFE']->id . '&type=' . $GLOBALS['TSFE']->type;
        for ($i = 1; $i < $pieces; $i++) {
            $len = strcspn($textpieces[$i], chr(32) . TAB . CRLF);
            if (trim(substr($textstr, -1)) == '' && $len) {
                $lastChar = substr($textpieces[$i], $len - 1, 1);
                if (!preg_match('/[A-Za-z0-9]/', $lastChar)) {
                    $len--;
                }
                $parts[0] = substr($textpieces[$i], 0, $len);
                $parts[1] = substr($textpieces[$i], $len);
                $linktxt = preg_replace('/\\?.*/', '', $parts[0]);
                list($mailToUrl, $linktxt) = $this->getMailTo($parts[0], $linktxt, $initP);
                $mailToUrl = $GLOBALS['TSFE']->spamProtectEmailAddresses === 'ascii' ? $mailToUrl : htmlspecialchars($mailToUrl);
                $res = '<a href="' . $mailToUrl . '"' . $aTagParams . '>';
                $wrap = isset($conf['wrap.']) ? $this->stdWrap($conf['wrap'], $conf['wrap.']) : $conf['wrap'];
                if ($conf['ATagBeforeWrap']) {
                    $res = $res . $this->wrap($linktxt, $wrap) . '</a>';
                } else {
                    $res = $this->wrap($res . $linktxt . '</a>', $wrap);
                }
                $textstr .= $res . $parts[1];
            } else {
                $textstr .= 'mailto:' . $textpieces[$i];
            }
        }
        return $textstr;
    }

    public function getImgResource($file, $fileArray) {
        if (empty($file) && empty($fileArray)) {
            return NULL;
        }
        if (!is_array($fileArray)) {
            $fileArray = (array) $fileArray;
        }
        $imageResource = NULL;
        if ($file === 'GIFBUILDER') {
            $gifCreator = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\Imaging\\GifBuilder');
            $gifCreator->init();
            $theImage = '';
            if ($GLOBALS['TYPO3_CONF_VARS']['GFX']['gdlib']) {
                $gifCreator->start($fileArray, $this->data);
                $theImage = $gifCreator->gifBuild();
            }
            $imageResource = $gifCreator->getImageDimensions($theImage);
            $imageResource['origFile'] = $theImage;
        } else {
            if ($file instanceof \TYPO3\CMS\Core\Resource\File) {
                $fileObject = $file;
            } elseif ($file instanceof \TYPO3\CMS\Core\Resource\FileReference) {
                $fileObject = $file->getOriginalFile();
            } else {
                try {
                    if ($fileArray['import.']) {
                        $importedFile = trim($this->stdWrap('', $fileArray['import.']));
                        if (!empty($importedFile)) {
                            $file = $importedFile;
                        }
                    }

                    if (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($file)) {
                        if (!empty($fileArray['treatIdAsReference'])) {
                            $fileObject = $this->getResourceFactory()->getFileReferenceObject($file)->getOriginalFile();
                        } else {
                            $fileObject = $this->getResourceFactory()->getFileObject($file);
                        }
                    } elseif (preg_match('/^(0|[1-9][0-9]*):/', $file)) { // combined identifier
                        $fileObject = $this->getResourceFactory()->retrieveFileOrFolderObject($file);
                    } else {
                        if (isset($importedFile) && !empty($importedFile) && !empty($fileArray['import'])) {
                            $file = $fileArray['import'] . $file;
                        }
                        // clean ../ sections of the path and resolve to proper string. This is necessary for the Tx_File_BackwardsCompatibility_TslibContentAdapter to work.
                        $file = GeneralUtility::resolveBackPath($file);
                        $fileObject = $this->getResourceFactory()->retrieveFileOrFolderObject($file);
                    }
                } catch (\TYPO3\CMS\Core\Resource\Exception $exception) {
                    $logger = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Log\\LogManager')->getLogger(__CLASS__);
                    $logger->warning('The image "' . $file . '" could not be found and won\'t be included in frontend output');
                    return NULL;
                }
            }
            if ($fileObject instanceof \TYPO3\CMS\Core\Resource\File) {
                $processingConfiguration = array();
                $processingConfiguration['width'] = isset($fileArray['width.']) ? $this->stdWrap($fileArray['width'], $fileArray['width.']) : $fileArray['width'];
                $processingConfiguration['height'] = isset($fileArray['height.']) ? $this->stdWrap($fileArray['height'], $fileArray['height.']) : $fileArray['height'];
                $processingConfiguration['fileExtension'] = isset($fileArray['ext.']) ? $this->stdWrap($fileArray['ext'], $fileArray['ext.']) : $fileArray['ext'];
                $processingConfiguration['maxWidth'] = isset($fileArray['maxW.']) ? (int)$this->stdWrap($fileArray['maxW'], $fileArray['maxW.']) : (int)$fileArray['maxW'];
                $processingConfiguration['maxHeight'] = isset($fileArray['maxH.']) ? (int)$this->stdWrap($fileArray['maxH'], $fileArray['maxH.']) : (int)$fileArray['maxH'];
                $processingConfiguration['minWidth'] = isset($fileArray['minW.']) ? (int)$this->stdWrap($fileArray['minW'], $fileArray['minW.']) : (int)$fileArray['minW'];
                $processingConfiguration['minHeight'] = isset($fileArray['minH.']) ? (int)$this->stdWrap($fileArray['minH'], $fileArray['minH.']) : (int)$fileArray['minH'];
                $processingConfiguration['noScale'] = isset($fileArray['noScale.']) ? $this->stdWrap($fileArray['noScale'], $fileArray['noScale.']) : $fileArray['noScale'];
                $processingConfiguration['additionalParameters'] = isset($fileArray['params.']) ? $this->stdWrap($fileArray['params'], $fileArray['params.']) : $fileArray['params'];
                $processingConfiguration['frame'] = isset($fileArray['frame.']) ? (int)$this->stdWrap($fileArray['frame'], $fileArray['frame.']) : (int)$fileArray['frame'];
                // Possibility to cancel/force profile extraction
                // see $TYPO3_CONF_VARS['GFX']['im_stripProfileCommand']
                if (isset($fileArray['stripProfile'])) {
                    $processingConfiguration['stripProfile'] = $fileArray['stripProfile'];
                }
                // Check if we can handle this type of file for editing
                if (GeneralUtility::inList($GLOBALS['TYPO3_CONF_VARS']['GFX']['imagefile_ext'], $fileObject->getExtension())) {
                    $maskArray = $fileArray['m.'];
                    // Must render mask images and include in hash-calculating
                    // - otherwise we cannot be sure the filename is unique for the setup!
                    if (is_array($maskArray)) {
                        $mask = $this->getImgResource($maskArray['mask'], $maskArray['mask.']);
                        $bgImg = $this->getImgResource($maskArray['bgImg'], $maskArray['bgImg.']);
                        $bottomImg = $this->getImgResource($maskArray['bottomImg'], $maskArray['bottomImg.']);
                        $bottomImg_mask = $this->getImgResource($maskArray['bottomImg_mask'], $maskArray['bottomImg_mask.']);

                        $processingConfiguration['maskImages']['maskImage'] = $mask['processedFile'];
                        $processingConfiguration['maskImages']['backgroundImage'] = $bgImg['processedFile'];
                        $processingConfiguration['maskImages']['maskBottomImage'] = $bottomImg['processedFile'];
                        $processingConfiguration['maskImages']['maskBottomImageMask'] = $bottomImg_mask['processedFile'];
                    }
                    if ($GLOBALS['TSFE']->config['config']['meaningfulTempFilePrefix']) {
                        $processingConfiguration['useTargetFileNameAsPrefix'] = 1;
                    }
                    $processedFileObject = $fileObject->process(\TYPO3\CMS\Core\Resource\ProcessedFile::CONTEXT_IMAGECROPSCALEMASK, $processingConfiguration);
                    $hash = $processedFileObject->calculateChecksum();
                    // store info in the TSFE template cache (kept for backwards compatibility)
                    if ($processedFileObject->isProcessed() && !isset($GLOBALS['TSFE']->tmpl->fileCache[$hash])) {
                        $GLOBALS['TSFE']->tmpl->fileCache[$hash] = array(
                            0 => $processedFileObject->getProperty('width'),
                            1 => $processedFileObject->getProperty('height'),
                            2 => $processedFileObject->getExtension(),
                            3 => $processedFileObject->getPublicUrl(),
                            'origFile' => $fileObject->getPublicUrl(),
                            'origFile_mtime' => $fileObject->getModificationTime(),
                            // This is needed by \TYPO3\CMS\Frontend\Imaging\GifBuilder,
                            // in order for the setup-array to create a unique filename hash.
                            'originalFile' => $fileObject,
                            'processedFile' => $processedFileObject,
                            'fileCacheHash' => $hash
                        );
                    }
                    $imageResource = $GLOBALS['TSFE']->tmpl->fileCache[$hash];
                }
            }
        }
        // If image was processed by GIFBUILDER:
        // ($imageResource indicates that it was processed the regular way)
        if (!isset($imageResource)) {
            $theImage = $GLOBALS['TSFE']->tmpl->getFileName($file);
            if ($theImage) {
                $gifCreator = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\Imaging\\GifBuilder');
                $gifCreator->init();
                $info = $gifCreator->imageMagickConvert($theImage, 'WEB');
                $info['origFile'] = $theImage;
                // This is needed by \TYPO3\CMS\Frontend\Imaging\GifBuilder, ln 100ff in order for the setup-array to create a unique filename hash.
                $info['origFile_mtime'] = @filemtime($theImage);
                $imageResource = $info;
            }
        }
        // Hook 'getImgResource': Post-processing of image resources
        if (isset($imageResource)) {
            foreach ($this->getGetImgResourceHookObjects() as $hookObject) {
                $imageResource = $hookObject->getImgResourcePostProcess($file, (array) $fileArray, $imageResource, $this);
            }
        }
        return $imageResource;
    }

    /***********************************************
     *
     * Data retrieval etc.
     *
     ***********************************************/
    public function getFieldVal($field) {
        if (!strstr($field, '//')) {
            return $this->data[trim($field)];
        } else {
            $sections = GeneralUtility::trimExplode('//', $field, TRUE);
            foreach ($sections as $k) {
                if ((string)$this->data[$k] !== '') {
                    return $this->data[$k];
                }
            }
        }
    }

    public function getData($string, $fieldArray = NULL) {
        if (!is_array($fieldArray)) {
            $fieldArray = $GLOBALS['TSFE']->page;
        }
        $retVal = '';
        $sections = explode('//', $string);
        while (!$retVal and list($secKey, $secVal) = each($sections)) {
            $parts = explode(':', $secVal, 2);
            $type = strtolower(trim($parts[0]));
            $typesWithOutParameters = array('level', 'date', 'current');
            $key = trim($parts[1]);
            if (($key != '') || in_array($type, $typesWithOutParameters)) {
                switch ($type) {
                    case 'gp':
                        // Merge GET and POST and get $key out of the merged array
                        $getPostArray = GeneralUtility::_GET();
                        \TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($getPostArray, GeneralUtility::_POST());
                        $retVal = $this->getGlobal($key, $getPostArray);
                        break;
                    case 'tsfe':
                        $retVal = $this->getGlobal('TSFE|' . $key);
                        break;
                    case 'getenv':
                        $retVal = getenv($key);
                        break;
                    case 'getindpenv':
                        $retVal = $this->getEnvironmentVariable($key);
                        break;
                    case 'field':
                        $retVal = $fieldArray[$key];
                        break;
                    case 'file':
                        $retVal = $this->getFileDataKey($key);
                        break;
                    case 'parameters':
                        $retVal = $this->parameters[$key];
                        break;
                    case 'register':
                        $retVal = $GLOBALS['TSFE']->register[$key];
                        break;
                    case 'global':
                        $retVal = $this->getGlobal($key);
                        break;
                    case 'level':
                        $retVal = count($GLOBALS['TSFE']->tmpl->rootLine) - 1;
                        break;
                    case 'leveltitle':
                        $keyParts = GeneralUtility::trimExplode(',', $key);
                        $numericKey = $this->getKey($keyParts[0], $GLOBALS['TSFE']->tmpl->rootLine);
                        $retVal = $this->rootLineValue($numericKey, 'title', strtolower($keyParts[1]) === 'slide');
                        break;
                    case 'levelmedia':
                        $keyParts = GeneralUtility::trimExplode(',', $key);
                        $numericKey = $this->getKey($keyParts[0], $GLOBALS['TSFE']->tmpl->rootLine);
                        $retVal = $this->rootLineValue($numericKey, 'media', strtolower($keyParts[1]) === 'slide');
                        break;
                    case 'leveluid':
                        $numericKey = $this->getKey($key, $GLOBALS['TSFE']->tmpl->rootLine);
                        $retVal = $this->rootLineValue($numericKey, 'uid');
                        break;
                    case 'levelfield':
                        $keyParts = GeneralUtility::trimExplode(',', $key);
                        $numericKey = $this->getKey($keyParts[0], $GLOBALS['TSFE']->tmpl->rootLine);
                        $retVal = $this->rootLineValue($numericKey, $keyParts[1], strtolower($keyParts[2]) === 'slide');
                        break;
                    case 'fullrootline':
                        $keyParts = GeneralUtility::trimExplode(',', $key);
                        $fullKey = (int)$keyParts[0] - count($GLOBALS['TSFE']->tmpl->rootLine) + count($GLOBALS['TSFE']->rootLine);
                        if ($fullKey >= 0) {
                            $retVal = $this->rootLineValue($fullKey, $keyParts[1], stristr($keyParts[2], 'slide'), $GLOBALS['TSFE']->rootLine);
                        }
                        break;
                    case 'date':
                        if (!$key) {
                            $key = 'd/m Y';
                        }
                        $retVal = date($key, $GLOBALS['EXEC_TIME']);
                        break;
                    case 'page':
                        $retVal = $GLOBALS['TSFE']->page[$key];
                        break;
                    case 'current':
                        $retVal = $this->data[$this->currentValKey];
                        break;
                    case 'db':
                        $selectParts = GeneralUtility::trimExplode(':', $key);
                        $db_rec = $GLOBALS['TSFE']->sys_page->getRawRecord($selectParts[0], $selectParts[1]);
                        if (is_array($db_rec) && $selectParts[2]) {
                            $retVal = $db_rec[$selectParts[2]];
                        }
                        break;
                    case 'lll':
                        $retVal = $GLOBALS['TSFE']->sL('LLL:' . $key);
                        break;
                    case 'path':
                        $retVal = $GLOBALS['TSFE']->tmpl->getFileName($key);
                        break;
                    case 'cobj':
                        switch ($key) {
                            case 'parentRecordNumber':
                                $retVal = $this->parentRecordNumber;
                                break;
                        }
                        break;
                    case 'debug':
                        switch ($key) {
                            case 'rootLine':
                                $retVal = \TYPO3\CMS\Core\Utility\DebugUtility::viewArray($GLOBALS['TSFE']->tmpl->rootLine);
                                break;
                            case 'fullRootLine':
                                $retVal = \TYPO3\CMS\Core\Utility\DebugUtility::viewArray($GLOBALS['TSFE']->rootLine);
                                break;
                            case 'data':
                                $retVal = \TYPO3\CMS\Core\Utility\DebugUtility::viewArray($this->data);
                                break;
                            case 'register':
                                $retVal = \TYPO3\CMS\Core\Utility\DebugUtility::viewArray($GLOBALS['TSFE']->register);
                                break;
                            case 'page':
                                $retVal = \TYPO3\CMS\Core\Utility\DebugUtility::viewArray($GLOBALS['TSFE']->page);
                                break;
                        }
                        break;
                }
            }
            if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getData'])) {
                foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getData'] as $classData) {
                    $hookObject = GeneralUtility::getUserObj($classData);
                    if (!$hookObject instanceof \TYPO3\CMS\Frontend\ContentObject\ContentObjectGetDataHookInterface) {
                        throw new \UnexpectedValueException('$hookObject must implement interface TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectGetDataHookInterface', 1195044480);
                    }
                    $retVal = $hookObject->getDataExtension($string, $fieldArray, $secVal, $retVal, $this);
                }
            }
        }
        return $retVal;
    }

    protected function getFileDataKey($key) {
        $parts = explode(':', $key);
        $fileUidOrCurrentKeyword = $parts[0];
        $requestedFileInformationKey = $parts[1];
        try {
            if ($fileUidOrCurrentKeyword === 'current') {
                $fileObject = $this->getCurrentFile();
            } elseif (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($fileUidOrCurrentKeyword)) {
                $fileFactory = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\ResourceFactory');
                $fileObject = $fileFactory->getFileObject($fileUidOrCurrentKeyword);
            } else {
                $fileObject = NULL;
            }
        } catch (\TYPO3\CMS\Core\Resource\Exception $exception) {
            $logger = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Log\\LogManager')->getLogger(__CLASS__);
            $logger->warning('The file "' . $fileUidOrCurrentKeyword . '" could not be found and won\'t be included in frontend output');
            $fileObject = NULL;
        }

        if ($fileObject instanceof \TYPO3\CMS\Core\Resource\FileInterface) {
            // All properties of the \TYPO3\CMS\Core\Resource\FileInterface are available here:
            switch ($requestedFileInformationKey) {
                case 'name':
                    return $fileObject->getName();
                    break;
                case 'uid':
                    return $fileObject->getUid();
                    break;
                case 'originalUid':
                    if ($fileObject instanceof \TYPO3\CMS\Core\Resource\FileReference) {
                        return $fileObject->getOriginalFile()->getUid();
                    } else {
                        return NULL;
                    }
                    break;
                case 'size':
                    return $fileObject->getSize();
                    break;
                case 'sha1':
                    return $fileObject->getSha1();
                    break;
                case 'extension':
                    return $fileObject->getExtension();
                    break;
                case 'mimetype':
                    return $fileObject->getMimeType();
                    break;
                case 'contents':
                    return $fileObject->getContents();
                    break;
                case 'publicUrl':
                    return $fileObject->getPublicUrl();
                    break;
                case 'localPath':
                    return $fileObject->getForLocalProcessing(FALSE);
                    break;
                default:
                    // Generic alternative here
                    return $fileObject->getProperty($requestedFileInformationKey);
            }
        } else {
            // TODO: fail silently as is common in tslib_content
            return 'Error: no file object';
        }
    }

    public function rootLineValue($key, $field, $slideBack = 0, $altRootLine = '') {
        $rootLine = is_array($altRootLine) ? $altRootLine : $GLOBALS['TSFE']->tmpl->rootLine;
        if (!$slideBack) {
            return $rootLine[$key][$field];
        } else {
            for ($a = $key; $a >= 0; $a--) {
                $val = $rootLine[$a][$field];
                if ($val) {
                    return $val;
                }
            }
        }
    }

    public function getGlobal($keyString, $source = NULL) {
        $keys = explode('|', $keyString);
        $numberOfLevels = count($keys);
        $rootKey = trim($keys[0]);
        $value = isset($source) ? $source[$rootKey] : $GLOBALS[$rootKey];
        for ($i = 1; $i < $numberOfLevels && isset($value); $i++) {
            $currentKey = trim($keys[$i]);
            if (is_object($value)) {
                $value = $value->{$currentKey};
            } elseif (is_array($value)) {
                $value = $value[$currentKey];
            } else {
                $value = '';
                break;
            }
        }
        if (!is_scalar($value)) {
            $value = '';
        }
        return $value;
    }

    public function getKey($key, $arr) {
        $key = (int)$key;
        if (is_array($arr)) {
            if ($key < 0) {
                $key = count($arr) + $key;
            }
            if ($key < 0) {
                $key = 0;
            }
        }
        return $key;
    }

    public function TCAlookup($inputValue, $conf) {
        $table = $conf['table'];
        $field = $conf['field'];
        $delimiter = $conf['delimiter'] ? $conf['delimiter'] : ' ,';
        if (is_array($GLOBALS['TCA'][$table]) && is_array($GLOBALS['TCA'][$table]['columns'][$field]) && is_array($GLOBALS['TCA'][$table]['columns'][$field]['config']['items'])) {
            $values = GeneralUtility::trimExplode(',', $inputValue);
            $output = array();
            foreach ($values as $value) {
                // Traverse the items-array...
                foreach ($GLOBALS['TCA'][$table]['columns'][$field]['config']['items'] as $item) {
                    // ... and return the first found label where the value was equal to $key
                    if ((string)$item[1] === trim($value)) {
                        $output[] = $GLOBALS['TSFE']->sL($item[0]);
                    }
                }
            }
            $returnValue = implode($delimiter, $output);
        } else {
            $returnValue = $inputValue;
        }
        return $returnValue;
    }

    /***********************************************
     *
     * Link functions (typolink)
     *
     ***********************************************/
    public function typoLink($linktxt, $conf) {
        $LD = array();
        $finalTagParts = array();
        $finalTagParts['aTagParams'] = $this->getATagParams($conf);
        $link_param = isset($conf['parameter.']) ? trim($this->stdWrap($conf['parameter'], $conf['parameter.'])) : trim($conf['parameter']);
        $sectionMark = isset($conf['section.']) ? trim($this->stdWrap($conf['section'], $conf['section.'])) : trim($conf['section']);
        $sectionMark = $sectionMark ? (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($sectionMark) ? '#c' : '#') . $sectionMark : '';
        $initP = '?id=' . $GLOBALS['TSFE']->id . '&type=' . $GLOBALS['TSFE']->type;
        $this->lastTypoLinkUrl = '';
        $this->lastTypoLinkTarget = '';
        if ($link_param) {
            $enableLinksAcrossDomains = $GLOBALS['TSFE']->config['config']['typolinkEnableLinksAcrossDomains'];
            $link_paramA = GeneralUtility::unQuoteFilenames($link_param, TRUE);
            // Check for link-handler keyword:
            list($linkHandlerKeyword, $linkHandlerValue) = explode(':', trim($link_paramA[0]), 2);
            if ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['typolinkLinkHandler'][$linkHandlerKeyword] && (string)$linkHandlerValue !== '') {
                $linkHandlerObj = GeneralUtility::getUserObj($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['typolinkLinkHandler'][$linkHandlerKeyword]);
                if (method_exists($linkHandlerObj, 'main')) {
                    return $linkHandlerObj->main($linktxt, $conf, $linkHandlerKeyword, $linkHandlerValue, $link_param, $this);
                }
            }
            // Resolve FAL-api "file:UID-of-sys_file-record" and "file:combined-identifier"
            if ($linkHandlerKeyword === 'file' && !GeneralUtility::isFirstPartOfStr($link_paramA[0], 'file://')) {
                try {
                    $fileOrFolderObject = $this->getResourceFactory()->retrieveFileOrFolderObject($linkHandlerValue);
                    // Link to a folder or file
                    if ($fileOrFolderObject instanceof \TYPO3\CMS\Core\Resource\ResourceInterface) {
                        $link_paramA[0] = $fileOrFolderObject->getPublicUrl();
                    } else {
                        $link_paramA[0] = NULL;
                    }
                } catch (\RuntimeException $e) {
                    // Element wasn't found
                    $link_paramA[0] = NULL;
                } catch (\TYPO3\CMS\Core\Resource\Exception\ResourceDoesNotExistException $e) {
                    // Resource was not found
                    return $linktxt;
                }
            // Disallow direct javascript: or data: links
            } elseif (in_array(strtolower(trim($linkHandlerKeyword)), array('javascript', 'data'), TRUE)) {
                return $linktxt;
            }
            // Link parameter value
            $link_param = trim($link_paramA[0]);
            // Link class
            $linkClass = trim($link_paramA[2]);
            if ($linkClass == '-') {
                // The '-' character means 'no class'. Necessary in order to specify a title as fourth parameter without setting the target or class!
                $linkClass = '';
            }
            // Target value
            $forceTarget = trim($link_paramA[1]);
            if ($forceTarget == '-') {
                // The '-' character means 'no target'. Necessary in order to specify a class as third parameter without setting the target!
                $forceTarget = '';
            }
            // Title value
            $forceTitle = trim($link_paramA[3]);
            if ($forceTitle == '-') {
                // The '-' character means 'no title'. Necessary in order to specify further parameters without setting the title!
                $forceTitle = '';
            }
            if (isset($link_paramA[4]) && strlen(trim($link_paramA[4])) > 0) {
                $forceParams = trim($link_paramA[4]);
                // params value
                $conf['additionalParams'] .= $forceParams[0] == '&' ? $forceParams : '&' . $forceParams;
            }
            // Check, if the target is coded as a JS open window link:
            $JSwindowParts = array();
            $JSwindowParams = '';
            $onClick = '';
            if ($forceTarget && preg_match('/^([0-9]+)x([0-9]+)(:(.*)|.*)$/', $forceTarget, $JSwindowParts)) {
                // Take all pre-configured and inserted parameters and compile parameter list, including width+height:
                $JSwindow_tempParamsArr = GeneralUtility::trimExplode(',', strtolower($conf['JSwindow_params'] . ',' . $JSwindowParts[4]), TRUE);
                $JSwindow_paramsArr = array();
                foreach ($JSwindow_tempParamsArr as $JSv) {
                    list($JSp, $JSv) = explode('=', $JSv);
                    $JSwindow_paramsArr[$JSp] = $JSp . '=' . $JSv;
                }
                // Add width/height:
                $JSwindow_paramsArr['width'] = 'width=' . $JSwindowParts[1];
                $JSwindow_paramsArr['height'] = 'height=' . $JSwindowParts[2];
                // Imploding into string:
                $JSwindowParams = implode(',', $JSwindow_paramsArr);
                // Resetting the target since we will use onClick.
                $forceTarget = '';
            }
            // Internal target:
            if ($GLOBALS['TSFE']->dtdAllowsFrames) {
                $target = isset($conf['target']) ? $conf['target'] : $GLOBALS['TSFE']->intTarget;
            } else {
                $target = isset($conf['target']) ? $conf['target'] : '';
            }
            if ($conf['target.']) {
                $target = $this->stdWrap($target, $conf['target.']);
            }
            // Title tag
            $title = $conf['title'];
            if ($conf['title.']) {
                $title = $this->stdWrap($title, $conf['title.']);
            }
            // Parse URL:
            $pU = parse_url($link_param);
            // Detecting kind of link:
            // If it's a mail address:
            if (strstr($link_param, '@') && (!$pU['scheme'] || $pU['scheme'] == 'mailto')) {
                $link_param = preg_replace('/^mailto:/i', '', $link_param);
                list($this->lastTypoLinkUrl, $linktxt) = $this->getMailTo($link_param, $linktxt, $initP);
                $finalTagParts['url'] = $this->lastTypoLinkUrl;
                $finalTagParts['TYPE'] = 'mailto';
            } else {
                $isLocalFile = 0;
                $fileChar = (int)strpos($link_param, '/');
                $urlChar = (int)strpos($link_param, '.');
                // Firsts, test if $link_param is numeric and page with such id exists. If yes, do not attempt to link to file
                if (!\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($link_param) || count($GLOBALS['TSFE']->sys_page->getPage_noCheck($link_param)) == 0) {
                    // Detects if a file is found in site-root and if so it will be treated like a normal file.
                    list($rootFileDat) = explode('?', rawurldecode($link_param));
                    $containsSlash = strstr($rootFileDat, '/');
                    $rFD_fI = pathinfo($rootFileDat);
                    if (trim($rootFileDat) && !$containsSlash && (@is_file((PATH_site . $rootFileDat)) || GeneralUtility::inList('php,html,htm', strtolower($rFD_fI['extension'])))) {
                        $isLocalFile = 1;
                    } elseif ($containsSlash) {
                        // Adding this so realurl directories are linked right (non-existing).
                        $isLocalFile = 2;
                    }
                }
                if ($pU['scheme'] || $isLocalFile != 1 && $urlChar && (!$containsSlash || $urlChar < $fileChar)) {
                    // url (external): If doubleSlash or if a '.' comes before a '/'.
                    if ($GLOBALS['TSFE']->dtdAllowsFrames) {
                        $target = isset($conf['extTarget']) ? $conf['extTarget'] : $GLOBALS['TSFE']->extTarget;
                    } else {
                        $target = isset($conf['extTarget']) ? $conf['extTarget'] : '';
                    }
                    if ($conf['extTarget.']) {
                        $target = $this->stdWrap($target, $conf['extTarget.']);
                    }
                    if ($forceTarget) {
                        $target = $forceTarget;
                    }
                    if ($linktxt == '') {
                        $linktxt = $this->parseFunc($link_param, array('makelinks' => 0), '< lib.parseFunc');
                    }
                    if (!$pU['scheme']) {
                        $scheme = 'http://';
                    } else {
                        $scheme = '';
                    }
                    if ($GLOBALS['TSFE']->config['config']['jumpurl_enable']) {
                        $url = $GLOBALS['TSFE']->absRefPrefix . $GLOBALS['TSFE']->config['mainScript'] . $initP;
                        $jumpurl = $scheme . $link_param;
                        $juHash = GeneralUtility::hmac($jumpurl, 'jumpurl');
                        $this->lastTypoLinkUrl = $url . '&jumpurl=' . rawurlencode($jumpurl) . '&juHash='. $juHash . $GLOBALS['TSFE']->getMethodUrlIdToken;
                    } else {
                        $this->lastTypoLinkUrl = $scheme . $link_param;
                    }
                    $this->lastTypoLinkTarget = $target;
                    $finalTagParts['url'] = $this->lastTypoLinkUrl;
                    $finalTagParts['targetParams'] = $target ? ' target="' . htmlspecialchars($target) . '"' : '';
                    $finalTagParts['TYPE'] = 'url';
                    $finalTagParts['aTagParams'] .= $this->extLinkATagParams($finalTagParts['url'], $finalTagParts['TYPE']);
                } elseif ($containsSlash || $isLocalFile) {
                    // file (internal)
                    $splitLinkParam = explode('?', $link_param);
                    if (file_exists(rawurldecode($splitLinkParam[0])) || $isLocalFile) {
                        if ($linktxt == '') {
                            $linktxt = $this->parseFunc(rawurldecode($link_param), array('makelinks' => 0), '< lib.parseFunc');
                        }
                        if ($GLOBALS['TSFE']->config['config']['jumpurl_enable'] || $conf['jumpurl']) {
                            $theFileEnc = str_replace('%2F', '/', rawurlencode(rawurldecode($link_param)));
                            $url = $GLOBALS['TSFE']->absRefPrefix . $GLOBALS['TSFE']->config['mainScript'] . $initP . '&jumpurl=' . rawurlencode($link_param);
                            if ($conf['jumpurl.']['secure']) {
                                $url .= $this->locDataJU($theFileEnc, $conf['jumpurl.']['secure.']);
                            } else {
                                $url .= '&juHash=' . GeneralUtility::hmac($link_param, 'jumpurl');
                            }
                            $this->lastTypoLinkUrl =  $url . $GLOBALS['TSFE']->getMethodUrlIdToken;
                        } else {
                            $this->lastTypoLinkUrl = $GLOBALS['TSFE']->absRefPrefix . $link_param;
                        }
                        $this->lastTypoLinkUrl = $this->forceAbsoluteUrl($this->lastTypoLinkUrl, $conf);
                        $target = isset($conf['fileTarget']) ? $conf['fileTarget'] : $GLOBALS['TSFE']->fileTarget;
                        if ($conf['fileTarget.']) {
                            $target = $this->stdWrap($target, $conf['fileTarget.']);
                        }
                        if ($forceTarget) {
                            $target = $forceTarget;
                        }
                        $this->lastTypoLinkTarget = $target;
                        $finalTagParts['url'] = $this->lastTypoLinkUrl;
                        $finalTagParts['targetParams'] = $target ? ' target="' . htmlspecialchars($target) . '"' : '';
                        $finalTagParts['TYPE'] = 'file';
                        $finalTagParts['aTagParams'] .= $this->extLinkATagParams($finalTagParts['url'], $finalTagParts['TYPE']);
                    } else {
                        $GLOBALS['TT']->setTSlogMessage('typolink(): File \'' . $splitLinkParam[0] . '\' did not exist, so \'' . $linktxt . '\' was not linked.', 1);
                        return $linktxt;
                    }
                } else {
                    // Integer or alias (alias is without slashes or periods or commas, that is
                    // 'nospace,alphanum_x,lower,unique' according to definition in $GLOBALS['TCA']!)
                    if ($conf['no_cache.']) {
                        $conf['no_cache'] = $this->stdWrap($conf['no_cache'], $conf['no_cache.']);
                    }
                    // Splitting the parameter by ',' and if the array counts more than 1 element it's a id/type/parameters triplet
                    $pairParts = GeneralUtility::trimExplode(',', $link_param, TRUE);
                    $link_param = $pairParts[0];
                    $link_params_parts = explode('#', $link_param);
                    // Link-data del
                    $link_param = trim($link_params_parts[0]);
                    // If no id or alias is given
                    if ($link_param === '') {
                        $link_param = $GLOBALS['TSFE']->id;
                    }
                    if ($link_params_parts[1] && !$sectionMark) {
                        $sectionMark = trim($link_params_parts[1]);
                        $sectionMark = (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($sectionMark) ? '#c' : '#') . $sectionMark;
                    }
                    if (count($pairParts) > 1) {
                        // Overruling 'type'
                        $theTypeP = isset($pairParts[1]) ? $pairParts[1] : 0;
                        $conf['additionalParams'] .= isset($pairParts[2]) ? $pairParts[2] : '';
                    }
                    // Checking if the id-parameter is an alias.
                    if (!\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($link_param)) {
                        $link_param = $GLOBALS['TSFE']->sys_page->getPageIdFromAlias($link_param);
                    }
                    // Link to page even if access is missing?
                    if (strlen($conf['linkAccessRestrictedPages'])) {
                        $disableGroupAccessCheck = $conf['linkAccessRestrictedPages'] ? TRUE : FALSE;
                    } else {
                        $disableGroupAccessCheck = $GLOBALS['TSFE']->config['config']['typolinkLinkAccessRestrictedPages'] ? TRUE : FALSE;
                    }
                    // Looking up the page record to verify its existence:
                    $page = $GLOBALS['TSFE']->sys_page->getPage($link_param, $disableGroupAccessCheck);
                    if (count($page)) {
                        // MointPoints, look for closest MPvar:
                        $MPvarAcc = array();
                        if (!$GLOBALS['TSFE']->config['config']['MP_disableTypolinkClosestMPvalue']) {
                            $temp_MP = $this->getClosestMPvalueForPage($page['uid'], TRUE);
                            if ($temp_MP) {
                                $MPvarAcc['closest'] = $temp_MP;
                            }
                        }
                        // Look for overlay Mount Point:
                        $mount_info = $GLOBALS['TSFE']->sys_page->getMountPointInfo($page['uid'], $page);
                        if (is_array($mount_info) && $mount_info['overlay']) {
                            $page = $GLOBALS['TSFE']->sys_page->getPage($mount_info['mount_pid'], $disableGroupAccessCheck);
                            if (!count($page)) {
                                $GLOBALS['TT']->setTSlogMessage('typolink(): Mount point \'' . $mount_info['mount_pid'] . '\' was not available, so \'' . $linktxt . '\' was not linked.', 1);
                                return $linktxt;
                            }
                            $MPvarAcc['re-map'] = $mount_info['MPvar'];
                        }
                        // Setting title if blank value to link:
                        if ($linktxt == '') {
                            $linktxt = $this->parseFunc($page['title'], array('makelinks' => 0), '< lib.parseFunc');
                        }
                        // Query Params:
                        $addQueryParams = $conf['addQueryString'] ? $this->getQueryArguments($conf['addQueryString.']) : '';
                        $addQueryParams .= isset($conf['additionalParams.']) ? trim($this->stdWrap($conf['additionalParams'], $conf['additionalParams.'])) : trim($conf['additionalParams']);
                        if ($addQueryParams === '&' || $addQueryParams[0] !== '&') {
                            $addQueryParams = '';
                        }
                        $targetDomain = '';
                        $currentDomain = $this->getEnvironmentVariable('HTTP_HOST');
                        // Mount pages are always local and never link to another domain
                        if (count($MPvarAcc)) {
                            // Add "&MP" var:
                            $addQueryParams .= '&MP=' . rawurlencode(implode(',', $MPvarAcc));
                        } elseif (strpos($addQueryParams, '&MP=') === FALSE && $GLOBALS['TSFE']->config['config']['typolinkCheckRootline']) {
                            // We do not come here if additionalParams had '&MP='. This happens when typoLink is called from
                            // menu. Mount points always work in the content of the current domain and we must not change
                            // domain if MP variables exist.
                            // If we link across domains and page is free type shortcut, we must resolve the shortcut first!
                            // If we do not do it, TYPO3 will fail to (1) link proper page in RealURL/CoolURI because
                            // they return relative links and (2) show proper page if no RealURL/CoolURI exists when link is clicked
                            if ($enableLinksAcrossDomains && $page['doktype'] == \TYPO3\CMS\Frontend\Page\PageRepository::DOKTYPE_SHORTCUT && $page['shortcut_mode'] == \TYPO3\CMS\Frontend\Page\PageRepository::SHORTCUT_MODE_NONE) {
                                // Save in case of broken destination or endless loop
                                $page2 = $page;
                                // Same as in RealURL, seems enough
                                $maxLoopCount = 20;
                                while ($maxLoopCount && is_array($page) && $page['doktype'] == \TYPO3\CMS\Frontend\Page\PageRepository::DOKTYPE_SHORTCUT && $page['shortcut_mode'] == \TYPO3\CMS\Frontend\Page\PageRepository::SHORTCUT_MODE_NONE) {
                                    $page = $GLOBALS['TSFE']->sys_page->getPage($page['shortcut'], $disableGroupAccessCheck);
                                    $maxLoopCount--;
                                }
                                if (count($page) == 0 || $maxLoopCount == 0) {
                                    // We revert if shortcut is broken or maximum number of loops is exceeded (indicates endless loop)
                                    $page = $page2;
                                }
                            }

                            $targetDomain = $GLOBALS['TSFE']->getDomainNameForPid($page['uid']);
                            // Do not prepend the domain if it is the current hostname
                            if (!$targetDomain || $GLOBALS['TSFE']->domainNameMatchesCurrentRequest($targetDomain)) {
                                $targetDomain = '';
                            }
                        }
                        if ($conf['useCacheHash']) {
                            $params = $GLOBALS['TSFE']->linkVars . $addQueryParams . '&id=' . $page['uid'];
                            if (trim($params, '& ') != '') {
                                $cacheHash = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\Page\\CacheHashCalculator');
                                $cHash = $cacheHash->generateForParameters($params);
                                $addQueryParams .= $cHash ? '&cHash=' . $cHash : '';
                            }
                            unset($params);
                        }
                        $absoluteUrlScheme = 'http';
                        // URL shall be absolute:
                        if (isset($conf['forceAbsoluteUrl']) && $conf['forceAbsoluteUrl'] || $page['url_scheme'] > 0) {
                            // Override scheme:
                            if (isset($conf['forceAbsoluteUrl.']['scheme']) && $conf['forceAbsoluteUrl.']['scheme']) {
                                $absoluteUrlScheme = $conf['forceAbsoluteUrl.']['scheme'];
                            } elseif ($page['url_scheme'] > 0) {
                                $absoluteUrlScheme = (int)$page['url_scheme'] === \TYPO3\CMS\Core\Utility\HttpUtility::SCHEME_HTTP ? 'http' : 'https';
                            } elseif ($this->getEnvironmentVariable('TYPO3_SSL')) {
                                $absoluteUrlScheme = 'https';
                            }
                            // If no domain records are defined, use current domain:
                            $currentUrlScheme = parse_url($this->getEnvironmentVariable('TYPO3_REQUEST_URL'), PHP_URL_SCHEME);
                            if ($targetDomain === '' && ($conf['forceAbsoluteUrl'] || $absoluteUrlScheme !== $currentUrlScheme)) {
                                $targetDomain = $currentDomain;
                            }
                            // If go for an absolute link, add site path if it's not taken care about by absRefPrefix
                            if (!$GLOBALS['TSFE']->config['config']['absRefPrefix'] && $targetDomain == $currentDomain) {
                                $targetDomain = $currentDomain . rtrim($this->getEnvironmentVariable('TYPO3_SITE_PATH'), '/');
                            }
                        }
                        // If target page has a different domain and the current domain's linking scheme (e.g. RealURL/...) should not be used
                        if (strlen($targetDomain) && $targetDomain !== $currentDomain && !$enableLinksAcrossDomains) {
                            $target = isset($conf['extTarget']) ? $conf['extTarget'] : $GLOBALS['TSFE']->extTarget;
                            if ($conf['extTarget.']) {
                                $target = $this->stdWrap($target, $conf['extTarget.']);
                            }
                            if ($forceTarget) {
                                $target = $forceTarget;
                            }
                            $LD['target'] = $target;
                            // Convert IDNA-like domain (if any)
                            if (!preg_match('/^[a-z0-9.\\-]*$/i', $targetDomain)) {
                                $targetDomain =  GeneralUtility::idnaEncode($targetDomain);
                            }
                            $this->lastTypoLinkUrl = $this->URLqMark(($absoluteUrlScheme . '://' . $targetDomain . '/index.php?id=' . $page['uid']), $addQueryParams) . $sectionMark;
                        } else {
                            // Internal link or current domain's linking scheme should be used
                            if ($forceTarget) {
                                $target = $forceTarget;
                            }
                            $LD = $GLOBALS['TSFE']->tmpl->linkData($page, $target, $conf['no_cache'], '', '', $addQueryParams, $theTypeP, $targetDomain);
                            if (strlen($targetDomain)) {
                                // We will add domain only if URL does not have it already.
                                if ($enableLinksAcrossDomains && $targetDomain !== $currentDomain) {
                                    // Get rid of the absRefPrefix if necessary. absRefPrefix is applicable only
                                    // to the current web site. If we have domain here it means we link across
                                    // domains. absRefPrefix can contain domain name, which will screw up
                                    // the link to the external domain.
                                    $prefixLength = strlen($GLOBALS['TSFE']->config['config']['absRefPrefix']);
                                    if (substr($LD['totalURL'], 0, $prefixLength) == $GLOBALS['TSFE']->config['config']['absRefPrefix']) {
                                        $LD['totalURL'] = substr($LD['totalURL'], $prefixLength);
                                    }
                                }
                                $urlParts = parse_url($LD['totalURL']);
                                if ($urlParts['host'] == '') {
                                    $LD['totalURL'] = $absoluteUrlScheme . '://' . $targetDomain . ($LD['totalURL'][0] == '/' ? '' : '/') . $LD['totalURL'];
                                }
                            }
                            $this->lastTypoLinkUrl = $this->URLqMark($LD['totalURL'], '') . $sectionMark;
                        }
                        $this->lastTypoLinkTarget = $LD['target'];
                        $targetPart = $LD['target'] ? ' target="' . htmlspecialchars($LD['target']) . '"' : '';
                        // If sectionMark is set, there is no baseURL AND the current page is the page the link is to, check if there are any additional parameters or addQueryString parameters and if not, drop the url.
                        if ($sectionMark && !$GLOBALS['TSFE']->config['config']['baseURL'] && $page['uid'] == $GLOBALS['TSFE']->id && !trim($addQueryParams) && !($conf['addQueryString'] && $conf['addQueryString.'])) {
                            list(, $URLparams) = explode('?', $this->lastTypoLinkUrl);
                            list($URLparams) = explode('#', $URLparams);
                            parse_str($URLparams . $LD['orig_type'], $URLparamsArray);
                            // Type nums must match as well as page ids
                            if ((int)$URLparamsArray['type'] == $GLOBALS['TSFE']->type) {
                                unset($URLparamsArray['id']);
                                unset($URLparamsArray['type']);
                                // If there are no parameters left.... set the new url.
                                if (!count($URLparamsArray)) {
                                    $this->lastTypoLinkUrl = $sectionMark;
                                }
                            }
                        }
                        // If link is to a access restricted page which should be redirected, then find new URL:
                        if (empty($conf['linkAccessRestrictedPages']) && $GLOBALS['TSFE']->config['config']['typolinkLinkAccessRestrictedPages'] && $GLOBALS['TSFE']->config['config']['typolinkLinkAccessRestrictedPages'] !== 'NONE' && !$GLOBALS['TSFE']->checkPageGroupAccess($page)) {
                            $thePage = $GLOBALS['TSFE']->sys_page->getPage($GLOBALS['TSFE']->config['config']['typolinkLinkAccessRestrictedPages']);
                            $addParams = str_replace(
                                array(
                                    '###RETURN_URL###',
                                    '###PAGE_ID###'
                                ),
                                array(
                                    rawurlencode($this->lastTypoLinkUrl),
                                    $page['uid']
                                ),
                                $GLOBALS['TSFE']->config['config']['typolinkLinkAccessRestrictedPages_addParams']
                            );
                            $this->lastTypoLinkUrl = $this->getTypoLink_URL($thePage['uid'] . ($theTypeP ? ',' . $theTypeP : ''), $addParams, $target);
                            $this->lastTypoLinkUrl = $this->forceAbsoluteUrl($this->lastTypoLinkUrl, $conf);
                            $this->lastTypoLinkLD['totalUrl'] = $this->lastTypoLinkUrl;
                            $LD = $this->lastTypoLinkLD;
                        }
                        // Rendering the tag.
                        $finalTagParts['url'] = $this->lastTypoLinkUrl;
                        $finalTagParts['targetParams'] = $targetPart;
                        $finalTagParts['TYPE'] = 'page';
                    } else {
                        $GLOBALS['TT']->setTSlogMessage('typolink(): Page id \'' . $link_param . '\' was not found, so \'' . $linktxt . '\' was not linked.', 1);
                        return $linktxt;
                    }
                }
            }
            $this->lastTypoLinkLD = $LD;
            if ($forceTitle) {
                $title = $forceTitle;
            }
            if ($JSwindowParams) {
                // Create TARGET-attribute only if the right doctype is used
                if (!GeneralUtility::inList('xhtml_strict,xhtml_11,xhtml_2', $GLOBALS['TSFE']->xhtmlDoctype)) {
                    $target = ' target="FEopenLink"';
                } else {
                    $target = '';
                }
                $onClick = 'vHWin=window.open(' . GeneralUtility::quoteJSvalue($GLOBALS['TSFE']->baseUrlWrap($finalTagParts['url']), TRUE) . ',\'FEopenLink\',' . GeneralUtility::quoteJSvalue($JSwindowParams) . ');vHWin.focus();return false;';
                $res = '<a href="' . htmlspecialchars($finalTagParts['url']) . '"' . $target . ' onclick="' . htmlspecialchars($onClick) . '"' . ($title ? ' title="' . htmlspecialchars($title) . '"' : '') . ($linkClass ? ' class="' . htmlspecialchars($linkClass) . '"' : '') . $finalTagParts['aTagParams'] . '>';
            } else {
                if ($GLOBALS['TSFE']->spamProtectEmailAddresses === 'ascii' && $finalTagParts['TYPE'] === 'mailto') {
                    $res = '<a href="' . $finalTagParts['url'] . '"' . ($title ? ' title="' . htmlspecialchars($title) . '"' : '') . $finalTagParts['targetParams'] . ($linkClass ? ' class="' . htmlspecialchars($linkClass) . '"' : '') . $finalTagParts['aTagParams'] . '>';
                } else {
                    $res = '<a href="' . htmlspecialchars($finalTagParts['url']) . '"' . ($title ? ' title="' . $title . '"' : '') . $finalTagParts['targetParams'] . ($linkClass ? ' class="' . htmlspecialchars($linkClass) . '"' : '') . $finalTagParts['aTagParams'] . '>';
                }
            }
            // Call user function:
            if ($conf['userFunc']) {
                $finalTagParts['TAG'] = $res;
                $res = $this->callUserFunction($conf['userFunc'], $conf['userFunc.'], $finalTagParts);
            }
            // Hook: Call post processing function for link rendering:
            if (isset($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['typoLink_PostProc']) && is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['typoLink_PostProc'])) {
                $_params = array(
                    'conf' => &$conf,
                    'linktxt' => &$linktxt,
                    'finalTag' => &$res,
                    'finalTagParts' => &$finalTagParts
                );
                foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['typoLink_PostProc'] as $_funcRef) {
                    GeneralUtility::callUserFunction($_funcRef, $_params, $this);
                }
            }
            // If flag "returnLastTypoLinkUrl" set, then just return the latest URL made:
            if ($conf['returnLast']) {
                switch ($conf['returnLast']) {
                    case 'url':
                        return $this->lastTypoLinkUrl;
                        break;
                    case 'target':
                        return $this->lastTypoLinkTarget;
                        break;
                }
            }
            $wrap = isset($conf['wrap.']) ? $this->stdWrap($conf['wrap'], $conf['wrap.']) : $conf['wrap'];
            if ($conf['ATagBeforeWrap']) {
                return $res . $this->wrap($linktxt, $wrap) . '</a>';
            } else {
                return $this->wrap($res . $linktxt . '</a>', $wrap);
            }
        } else {
            return $linktxt;
        }
    }

    protected function forceAbsoluteUrl($url, array $configuration) {
        if (!empty($url) && isset($configuration['forceAbsoluteUrl']) && $configuration['forceAbsoluteUrl']) {
            if (preg_match('#^(?:([a-z]+)(://)([^/]*)/?)?(.*)$#', $url, $matches)) {
                $urlParts = array(
                    'scheme' => $matches[1],
                    'delimiter' => '://',
                    'host' => $matches[3],
                    'path' => $matches[4]
                );
                $isUrlModified = FALSE;
                // Set scheme and host if not yet part of the URL:
                if (empty($urlParts['host'])) {
                    $urlParts['scheme'] = 'http';
                    $urlParts['host'] = $this->getEnvironmentVariable('HTTP_HOST');
                    $urlParts['path'] = '/' . ltrim($urlParts['path'], '/');
                    // absRefPrefix has been prepended to $url beforehand
                    // so we only modify the path if no absRefPrefix has been set
                    // otherwise we would destroy the path
                    if ($GLOBALS['TSFE']->absRefPrefix === '') {
                        $urlParts['path'] = $this->getEnvironmentVariable('TYPO3_SITE_PATH') . ltrim($urlParts['path'], '/');
                    }
                    $isUrlModified = TRUE;
                }
                // Override scheme:
                $forceAbsoluteUrl = &$configuration['forceAbsoluteUrl.']['scheme'];
                if (!empty($forceAbsoluteUrl) && $urlParts['scheme'] !== $forceAbsoluteUrl) {
                    $urlParts['scheme'] = $forceAbsoluteUrl;
                    $isUrlModified = TRUE;
                }
                // Recreate the absolute URL:
                if ($isUrlModified) {
                    $url = implode('', $urlParts);
                }
            }
        }
        return $url;
    }

    public function typoLink_URL($conf) {
        $this->typolink('|', $conf);
        return $this->lastTypoLinkUrl;
    }

    public function getTypoLink($label, $params, $urlParameters = array(), $target = '') {
        $conf = array();
        $conf['parameter'] = $params;
        if ($target) {
            $conf['target'] = $target;
            $conf['extTarget'] = $target;
            $conf['fileTarget'] = $target;
        }
        if (is_array($urlParameters)) {
            if (count($urlParameters)) {
                $conf['additionalParams'] .= GeneralUtility::implodeArrayForUrl('', $urlParameters);
            }
        } else {
            $conf['additionalParams'] .= $urlParameters;
        }
        $out = $this->typolink($label, $conf);
        return $out;
    }

    public function getUrlToCurrentLocation($addQueryString = TRUE) {
        $conf = array();
        $conf['parameter'] = $GLOBALS['TSFE']->id . ',' . $GLOBALS['TSFE']->type;
        if ($addQueryString) {
            $conf['addQueryString'] = '1';
            $linkVars = implode(',', array_keys(GeneralUtility::explodeUrl2Array($GLOBALS['TSFE']->linkVars)));
            $conf['addQueryString.'] = array(
                'method' => 'GET',
                'exclude' => 'id,type,cHash' . ($linkVars ? ',' . $linkVars : '')
            );
            $conf['useCacheHash'] = GeneralUtility::_GET('cHash') ? '1' : '0';
        }

        return $this->typoLink_URL($conf);
    }

    public function getTypoLink_URL($params, $urlParameters = array(), $target = '') {
        $this->getTypoLink('', $params, $urlParameters, $target);
        return $this->lastTypoLinkUrl;
    }

    public function typolinkWrap($conf) {
        $k = md5(microtime());
        return explode($k, $this->typolink($k, $conf));
    }

    public function currentPageUrl($urlParameters = array(), $id = 0) {
        return $this->getTypoLink_URL($id ? $id : $GLOBALS['TSFE']->id, $urlParameters, $GLOBALS['TSFE']->sPre);
    }

    public function getClosestMPvalueForPage($pageId, $raw = FALSE) {
        // MountPoints:
        if ($GLOBALS['TYPO3_CONF_VARS']['FE']['enable_mount_pids'] && $GLOBALS['TSFE']->MP) {
            // Same page as current.
            if ((int)$GLOBALS['TSFE']->id === (int)$pageId) {
                $MP = $GLOBALS['TSFE']->MP;
            } else {
                // ... otherwise find closest meeting point:
                // Gets rootline of linked-to page
                $tCR_rootline = $GLOBALS['TSFE']->sys_page->getRootLine($pageId, '', TRUE);
                $inverseTmplRootline = array_reverse($GLOBALS['TSFE']->tmpl->rootLine);
                $rl_mpArray = array();
                $startMPaccu = FALSE;
                // Traverse root line of link uid and inside of that the REAL root line of current position.
                foreach ($tCR_rootline as $tCR_data) {
                    foreach ($inverseTmplRootline as $rlKey => $invTmplRLRec) {
                        // Force accumulating when in overlay mode: Links to this page have to stay within the current branch
                        if ($invTmplRLRec['_MOUNT_OL'] && $tCR_data['uid'] == $invTmplRLRec['uid']) {
                            $startMPaccu = TRUE;
                        }
                        // Accumulate MP data:
                        if ($startMPaccu && $invTmplRLRec['_MP_PARAM']) {
                            $rl_mpArray[] = $invTmplRLRec['_MP_PARAM'];
                        }
                        // If two PIDs matches and this is NOT the site root, start accumulation of MP data (on the next level):
                        // (The check for site root is done so links to branches outsite the site but sharing the site roots PID
                        // is NOT detected as within the branch!)
                        if ($tCR_data['pid'] == $invTmplRLRec['pid'] && count($inverseTmplRootline) != $rlKey + 1) {
                            $startMPaccu = TRUE;
                        }
                    }
                    if ($startMPaccu) {
                        // Good enough...
                        break;
                    }
                }
                if (count($rl_mpArray)) {
                    $MP = implode(',', array_reverse($rl_mpArray));
                }
            }
        }
        return !$raw ? ($MP ? '&MP=' . rawurlencode($MP) : '') : $MP;
    }

    public function getMailTo($mailAddress, $linktxt, $initP = '?') {
        if ((string)$linktxt === '') {
            $linktxt = htmlspecialchars($mailAddress);
        }
        $mailToUrl = 'mailto:' . $mailAddress;
        if (!$GLOBALS['TSFE']->config['config']['jumpurl_enable'] || $GLOBALS['TSFE']->config['config']['jumpurl_mailto_disable']) {
            if ($GLOBALS['TSFE']->spamProtectEmailAddresses) {
                if ($GLOBALS['TSFE']->spamProtectEmailAddresses === 'ascii') {
                    $mailToUrl = $GLOBALS['TSFE']->encryptEmail($mailToUrl);
                } else {
                    $mailToUrl = 'javascript:linkTo_UnCryptMailto(\'' . $GLOBALS['TSFE']->encryptEmail($mailToUrl) . '\');';
                }
                if ($GLOBALS['TSFE']->config['config']['spamProtectEmailAddresses_atSubst']) {
                    $atLabel = trim($GLOBALS['TSFE']->config['config']['spamProtectEmailAddresses_atSubst']);
                }
                $spamProtectedMailAddress = str_replace('@', $atLabel ? $atLabel : '(at)', htmlspecialchars($mailAddress));
                if ($GLOBALS['TSFE']->config['config']['spamProtectEmailAddresses_lastDotSubst']) {
                    $lastDotLabel = trim($GLOBALS['TSFE']->config['config']['spamProtectEmailAddresses_lastDotSubst']);
                    $lastDotLabel = $lastDotLabel ? $lastDotLabel : '(dot)';
                    $spamProtectedMailAddress = preg_replace('/\\.([^\\.]+)$/', $lastDotLabel . '$1', $spamProtectedMailAddress);
                }
                $linktxt = str_ireplace($mailAddress, $spamProtectedMailAddress, $linktxt);
            }
        } else {
            $juHash = GeneralUtility::hmac($mailToUrl, 'jumpurl');
            $mailToUrl = $GLOBALS['TSFE']->absRefPrefix . $GLOBALS['TSFE']->config['mainScript'] . $initP . '&jumpurl=' . rawurlencode($mailToUrl) . '&juHash=' . $juHash . $GLOBALS['TSFE']->getMethodUrlIdToken;
        }
        return array(
            $mailToUrl,
            $linktxt
        );
    }

    public function getQueryArguments($conf, $overruleQueryArguments = array(), $forceOverruleArguments = FALSE) {
        switch ((string) $conf['method']) {
            case 'GET':
                $currentQueryArray = GeneralUtility::_GET();
                break;
            case 'POST':
                $currentQueryArray = GeneralUtility::_POST();
                break;
            case 'GET,POST':
                $currentQueryArray = GeneralUtility::_GET();
                \TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($currentQueryArray, GeneralUtility::_POST());
                break;
            case 'POST,GET':
                $currentQueryArray = GeneralUtility::_POST();
                \TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($currentQueryArray, GeneralUtility::_GET());
                break;
            default:
                $currentQueryArray = GeneralUtility::explodeUrl2Array($this->getEnvironmentVariable('QUERY_STRING'), TRUE);
        }
        if ($conf['exclude']) {
            $exclude = str_replace(',', '&', $conf['exclude']);
            $exclude = GeneralUtility::explodeUrl2Array($exclude, TRUE);
            // never repeat id
            $exclude['id'] = 0;
            $newQueryArray = GeneralUtility::arrayDiffAssocRecursive($currentQueryArray, $exclude);
        } else {
            $newQueryArray = $currentQueryArray;
        }
        if ($forceOverruleArguments) {
            \TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($newQueryArray, $overruleQueryArguments);
        } else {
            \TYPO3\CMS\Core\Utility\ArrayUtility::mergeRecursiveWithOverrule($newQueryArray, $overruleQueryArguments, FALSE);
        }
        return GeneralUtility::implodeArrayForUrl('', $newQueryArray, '', FALSE, TRUE);
    }

    /***********************************************
     *
     * Miscellaneous functions, stand alone
     *
     ***********************************************/
    public function wrap($content, $wrap, $char = '|') {
        if ($wrap) {
            $wrapArr = explode($char, $wrap);
            return trim($wrapArr[0]) . $content . trim($wrapArr[1]);
        } else {
            return $content;
        }
    }

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

    public function wrapSpace($content, $wrap, array $conf = NULL) {
        if (trim($wrap)) {
            $wrapArray = explode('|', $wrap);
            $wrapBefore = (int)$wrapArray[0];
            $wrapAfter = (int)$wrapArray[1];
            $useDivTag = isset($conf['useDiv']) && $conf['useDiv'];
            if ($wrapBefore) {
                if ($useDivTag) {
                    $content = '<div class="content-spacer spacer-before" style="height:' . $wrapBefore . 'px;"></div>' . $content;
                } else {
                    $content = '<img src="' . $GLOBALS['TSFE']->absRefPrefix . 'clear.gif" width="1" height="' . $wrapBefore . '"' . $this->getBorderAttr(' border="0"') . ' class="spacer-gif" alt="" title="" /><br />' . $content;
                }
            }
            if ($wrapAfter) {
                if ($useDivTag) {
                    $content .= '<div class="content-spacer spacer-after" style="height:' . $wrapAfter . 'px;"></div>';
                } else {
                    $content .= '<img src="' . $GLOBALS['TSFE']->absRefPrefix . 'clear.gif" width="1" height="' . $wrapAfter . '"' . $this->getBorderAttr(' border="0"') . ' class="spacer-gif" alt="" title="" /><br />';
                }
            }
        }
        return $content;
    }

    public function callUserFunction($funcName, $conf, $content) {
        // Split parts
        $parts = explode('->', $funcName);
        if (count($parts) == 2) {
            // Class
            // Check whether class is available and try to reload includeLibs if possible:
            if ($this->isClassAvailable($parts[0], $conf)) {
                $classObj = GeneralUtility::makeInstance($parts[0]);
                if (is_object($classObj) && method_exists($classObj, $parts[1])) {
                    $classObj->cObj = $this;
                    $content = call_user_func_array(array(
                        $classObj,
                        $parts[1]
                    ), array(
                        $content,
                        $conf
                    ));
                } else {
                    $GLOBALS['TT']->setTSlogMessage('Method "' . $parts[1] . '" did not exist in class "' . $parts[0] . '"', 3);
                }
            } else {
                $GLOBALS['TT']->setTSlogMessage('Class "' . $parts[0] . '" did not exist', 3);
            }
        } else {
            // Function
            if (function_exists($funcName)) {
                $content = call_user_func($funcName, $content, $conf);
            } else {
                $GLOBALS['TT']->setTSlogMessage('Function "' . $funcName . '" did not exist', 3);
            }
        }
        return $content;
    }

    public function processParams($params) {
        $paramArr = array();
        $lines = GeneralUtility::trimExplode(LF, $params, TRUE);
        foreach ($lines as $val) {
            $pair = explode('=', $val, 2);
            $pair[0] = trim($pair[0]);
            if (!GeneralUtility::inList('#,/', $pair[0][0])) {
                $paramArr[$pair[0]] = trim($pair[1]);
            }
        }
        return $paramArr;
    }

    public function keywords($content) {
        $listArr = preg_split('/[,;' . LF . ']/', $content);
        foreach ($listArr as $k => $v) {
            $listArr[$k] = trim($v);
        }
        return implode(',', $listArr);
    }

    public function caseshift($theValue, $case) {
        $case = strtolower($case);
        switch ($case) {
            case 'upper':
                $theValue = $GLOBALS['TSFE']->csConvObj->conv_case($GLOBALS['TSFE']->renderCharset, $theValue, 'toUpper');
                break;
            case 'lower':
                $theValue = $GLOBALS['TSFE']->csConvObj->conv_case($GLOBALS['TSFE']->renderCharset, $theValue, 'toLower');
                break;
            case 'capitalize':
                $theValue = ucwords($theValue);
                break;
            case 'ucfirst':
                $theValue = $GLOBALS['TSFE']->csConvObj->convCaseFirst($GLOBALS['TSFE']->renderCharset, $theValue, 'toUpper');
                break;
            case 'lcfirst':
                $theValue = $GLOBALS['TSFE']->csConvObj->convCaseFirst($GLOBALS['TSFE']->renderCharset, $theValue, 'toLower');
                break;
        }
        return $theValue;
    }

    public function HTMLcaseshift($theValue, $case) {
        $inside = 0;
        $newVal = '';
        $pointer = 0;
        $totalLen = strlen($theValue);
        do {
            if (!$inside) {
                $len = strcspn(substr($theValue, $pointer), '<');
                $newVal .= $this->caseshift(substr($theValue, $pointer, $len), $case);
                $inside = 1;
            } else {
                $len = strcspn(substr($theValue, $pointer), '>') + 1;
                $newVal .= substr($theValue, $pointer, $len);
                $inside = 0;
            }
            $pointer += $len;
        } while ($pointer < $totalLen);
        return $newVal;
    }

    public function calcAge($seconds, $labels) {
        if (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($labels)) {
            $labels = ' min| hrs| days| yrs| min| hour| day| year';
        } else {
            $labels = str_replace('"', '', $labels);
        }
        $labelArr = explode('|', $labels);
        if (count($labelArr) == 4) {
            $labelArr = array_merge($labelArr, $labelArr);
        }
        $absSeconds = abs($seconds);
        $sign = $seconds > 0 ? 1 : -1;
        if ($absSeconds < 3600) {
            $val = round($absSeconds / 60);
            $seconds = $sign * $val . ($val == 1 ? $labelArr[4] : $labelArr[0]);
        } elseif ($absSeconds < 24 * 3600) {
            $val = round($absSeconds / 3600);
            $seconds = $sign * $val . ($val == 1 ? $labelArr[5] : $labelArr[1]);
        } elseif ($absSeconds < 365 * 24 * 3600) {
            $val = round($absSeconds / (24 * 3600));
            $seconds = $sign * $val . ($val == 1 ? $labelArr[6] : $labelArr[2]);
        } else {
            $val = round($absSeconds / (365 * 24 * 3600));
            $seconds = $sign * $val . ($val == 1 ? $labelArr[7] : $labelArr[3]);
        }
        return $seconds;
    }

    public function sendNotifyEmail($message, $recipients, $cc, $senderAddress, $senderName = '', $replyTo = '') {
        $result = FALSE;
        $mail = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Mail\\MailMessage');
        $senderName = trim($senderName);
        $senderAddress = trim($senderAddress);
        if ($senderName !== '' && $senderAddress !== '') {
            $sender = array($senderAddress => $senderName);
        } elseif ($senderAddress !== '') {
            $sender = array($senderAddress);
        } else {
            $sender = \TYPO3\CMS\Core\Utility\MailUtility::getSystemFrom();
        }
        $mail->setFrom($sender);
        $parsedReplyTo = \TYPO3\CMS\Core\Utility\MailUtility::parseAddresses($replyTo);
        if (count($parsedReplyTo) > 0) {
            $mail->setReplyTo($parsedReplyTo);
        }
        $message = trim($message);
        if ($message !== '') {
            // First line is subject
            $messageParts = explode(LF, $message, 2);
            $subject = trim($messageParts[0]);
            $plainMessage = trim($messageParts[1]);
            $parsedRecipients = \TYPO3\CMS\Core\Utility\MailUtility::parseAddresses($recipients);
            if (count($parsedRecipients) > 0) {
                $mail->setTo($parsedRecipients)
                    ->setSubject($subject)
                    ->setBody($plainMessage);
                $mail->send();
            }
            $parsedCc = \TYPO3\CMS\Core\Utility\MailUtility::parseAddresses($cc);
            if (count($parsedCc) > 0) {
                $mail = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Mail\\MailMessage');
                if (count($parsedReplyTo) > 0) {
                    $mail->setReplyTo($parsedReplyTo);
                }
                $mail->setFrom($sender)
                    ->setTo($parsedCc)
                    ->setSubject($subject)
                    ->setBody($plainMessage);
                $mail->send();
            }
            $result = TRUE;
        }
        return $result;
    }

    public function URLqMark($url, $params) {
        if ($params && !strstr($url, '?')) {
            return $url . '?' . $params;
        } else {
            return $url . $params;
        }
    }

    public function clearTSProperties($TSArr, $propList) {
        $list = explode(',', $propList);
        foreach ($list as $prop) {
            $prop = trim($prop);
            unset($TSArr[$prop]);
            unset($TSArr[$prop . '.']);
        }
        return $TSArr;
    }

    public function mergeTSRef($confArr, $prop) {
        if ($confArr[$prop][0] === '<') {
            $key = trim(substr($confArr[$prop], 1));
            $cF = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\TypoScript\\Parser\\TypoScriptParser');
            // $name and $conf is loaded with the referenced values.
            $old_conf = $confArr[$prop . '.'];
            list($name, $conf) = $cF->getVal($key, $GLOBALS['TSFE']->tmpl->setup);
            if (is_array($old_conf) && count($old_conf)) {
                $conf = is_array($conf) ? array_replace_recursive($conf, $old_conf) : $old_conf;
            }
            $confArr[$prop . '.'] = $conf;
        }
        return $confArr;
    }

    public function joinTSarrays($conf, $old_conf) {
        GeneralUtility::logDeprecatedFunction();
        return array_replace_recursive($conf, $old_conf);
    }

    public function gifBuilderTextBox($gifbuilderConf, $conf, $text) {
        $chars = (int)$conf['chars'] ?: 20;
        $lineDist = (int)$conf['lineDist'] ?: 20;
        $Valign = strtolower(trim($conf['Valign']));
        $tmplObjNumber = (int)$conf['tmplObjNumber'];
        $maxLines = (int)$conf['maxLines'];
        if ($tmplObjNumber && $gifbuilderConf[$tmplObjNumber] == 'TEXT') {
            $textArr = $this->linebreaks($text, $chars, $maxLines);
            $angle = (int)$gifbuilderConf[$tmplObjNumber . '.']['angle'];
            foreach ($textArr as $c => $textChunk) {
                $index = $tmplObjNumber + 1 + $c * 2;
                // Workarea
                $gifbuilderConf = $this->clearTSProperties($gifbuilderConf, $index);
                $rad_angle = 2 * pi() / 360 * $angle;
                $x_d = sin($rad_angle) * $lineDist;
                $y_d = cos($rad_angle) * $lineDist;
                $diff_x_d = 0;
                $diff_y_d = 0;
                if ($Valign == 'center') {
                    $diff_x_d = $x_d * count($textArr);
                    $diff_x_d = $diff_x_d / 2;
                    $diff_y_d = $y_d * count($textArr);
                    $diff_y_d = $diff_y_d / 2;
                }
                $x_d = round($x_d * $c - $diff_x_d);
                $y_d = round($y_d * $c - $diff_y_d);
                $gifbuilderConf[$index] = 'WORKAREA';
                $gifbuilderConf[$index . '.']['set'] = $x_d . ',' . $y_d;
                // Text
                $index++;
                $gifbuilderConf = $this->clearTSProperties($gifbuilderConf, $index);
                $gifbuilderConf[$index] = 'TEXT';
                $gifbuilderConf[$index . '.'] = $this->clearTSProperties($gifbuilderConf[$tmplObjNumber . '.'], 'text');
                $gifbuilderConf[$index . '.']['text'] = $textChunk;
            }
            $gifbuilderConf = $this->clearTSProperties($gifbuilderConf, $tmplObjNumber);
        }
        return $gifbuilderConf;
    }

    public function linebreaks($string, $chars, $maxLines = 0) {
        $lines = explode(LF, $string);
        $lineArr = array();
        $c = 0;
        foreach ($lines as $paragraph) {
            $words = explode(' ', $paragraph);
            foreach ($words as $word) {
                if (strlen($lineArr[$c] . $word) > $chars) {
                    $c++;
                }
                if (!$maxLines || $c < $maxLines) {
                    $lineArr[$c] .= $word . ' ';
                }
            }
            $c++;
        }
        return $lineArr;
    }

    public function getUpdateJS($dataArray, $formName, $arrPrefix, $fieldList) {
        $JSPart = '';
        $updateValues = GeneralUtility::trimExplode(',', $fieldList);
        foreach ($updateValues as $fKey) {
            $value = $dataArray[$fKey];
            if (is_array($value)) {
                foreach ($value as $Nvalue) {
                    $JSPart .= '
    updateForm(\'' . $formName . '\',\'' . $arrPrefix . '[' . $fKey . '][]\',' . GeneralUtility::quoteJSvalue($Nvalue, TRUE) . ');';
                }
            } else {
                $JSPart .= '
    updateForm(\'' . $formName . '\',\'' . $arrPrefix . '[' . $fKey . ']\',' . GeneralUtility::quoteJSvalue($value, TRUE) . ');';
            }
        }
        $JSPart = '<script type="text/javascript">
    /*<![CDATA[*/ ' . $JSPart . '
    /*]]>*/
</script>
';
        $GLOBALS['TSFE']->additionalHeaderData['JSincludeFormupdate'] = '<script type="text/javascript" src="' . GeneralUtility::createVersionNumberedFilename(($GLOBALS['TSFE']->absRefPrefix . 'typo3/js/jsfunc.updateform.js')) . '"></script>';
        return $JSPart;
    }

    public function includeLibs(array $config) {
        $librariesIncluded = FALSE;
        if (isset($config['includeLibs']) && $config['includeLibs']) {
            $libraries = GeneralUtility::trimExplode(',', $config['includeLibs'], TRUE);
            $GLOBALS['TSFE']->includeLibraries($libraries);
            $librariesIncluded = TRUE;
        }
        return $librariesIncluded;
    }

    protected function isClassAvailable($className, array $config = NULL) {
        if (class_exists($className)) {
            return TRUE;
        } elseif ($config) {
            $pluginConfiguration = &$GLOBALS['TSFE']->tmpl->setup['plugin.'][$className . '.'];
            if (isset($pluginConfiguration['includeLibs']) && $pluginConfiguration['includeLibs']) {
                $config['includeLibs'] = $pluginConfiguration['includeLibs'];
                return $this->includeLibs($config);
            }
        }
        return FALSE;
    }

    /***********************************************
     *
     * Database functions, making of queries
     *
     ***********************************************/
    public function DBgetDelete($table, $uid, $doExec = FALSE) {
        if ((int)$uid) {
            $uid = (int)$uid;
            if ($GLOBALS['TCA'][$table]['ctrl']['delete']) {
                $updateFields = array();
                $updateFields[$GLOBALS['TCA'][$table]['ctrl']['delete']] = 1;
                if ($GLOBALS['TCA'][$table]['ctrl']['tstamp']) {
                    $updateFields[$GLOBALS['TCA'][$table]['ctrl']['tstamp']] = $GLOBALS['EXEC_TIME'];
                }

                if ($doExec) {
                    return $GLOBALS['TYPO3_DB']->exec_UPDATEquery($table, 'uid=' . $uid, $updateFields);
                } else {
                    return $GLOBALS['TYPO3_DB']->UPDATEquery($table, 'uid=' . $uid, $updateFields);
                }
            } else {
                if ($doExec) {
                    return $GLOBALS['TYPO3_DB']->exec_DELETEquery($table, 'uid=' . $uid);
                } else {
                    return $GLOBALS['TYPO3_DB']->DELETEquery($table, 'uid=' . $uid);
                }
            }
        }
    }

    public function DBgetUpdate($table, $uid, $dataArr, $fieldList, $doExec = FALSE) {
        // uid can never be set
        unset($dataArr['uid']);
        $uid = (int)$uid;
        if ($uid) {
            $fieldList = implode(',', GeneralUtility::trimExplode(',', $fieldList, TRUE));
            $updateFields = array();
            foreach ($dataArr as $f => $v) {
                if (GeneralUtility::inList($fieldList, $f)) {
                    $updateFields[$f] = $v;
                }
            }
            if ($GLOBALS['TCA'][$table]['ctrl']['tstamp']) {
                $updateFields[$GLOBALS['TCA'][$table]['ctrl']['tstamp']] = $GLOBALS['EXEC_TIME'];
            }
            if (count($updateFields)) {
                if ($doExec) {
                    return $GLOBALS['TYPO3_DB']->exec_UPDATEquery($table, 'uid=' . $uid, $updateFields);
                } else {
                    return $GLOBALS['TYPO3_DB']->UPDATEquery($table, 'uid=' . $uid, $updateFields);
                }
            }
        }
    }

    public function DBgetInsert($table, $pid, $dataArr, $fieldList, $doExec = FALSE) {
        $extraList = 'pid';
        if ($GLOBALS['TCA'][$table]['ctrl']['tstamp']) {
            $field = $GLOBALS['TCA'][$table]['ctrl']['tstamp'];
            $dataArr[$field] = $GLOBALS['EXEC_TIME'];
            $extraList .= ',' . $field;
        }
        if ($GLOBALS['TCA'][$table]['ctrl']['crdate']) {
            $field = $GLOBALS['TCA'][$table]['ctrl']['crdate'];
            $dataArr[$field] = $GLOBALS['EXEC_TIME'];
            $extraList .= ',' . $field;
        }
        if ($GLOBALS['TCA'][$table]['ctrl']['cruser_id']) {
            $field = $GLOBALS['TCA'][$table]['ctrl']['cruser_id'];
            $dataArr[$field] = 0;
            $extraList .= ',' . $field;
        }
        if ($GLOBALS['TCA'][$table]['ctrl']['fe_cruser_id']) {
            $field = $GLOBALS['TCA'][$table]['ctrl']['fe_cruser_id'];
            $dataArr[$field] = (int)$GLOBALS['TSFE']->fe_user->user['uid'];
            $extraList .= ',' . $field;
        }
        if ($GLOBALS['TCA'][$table]['ctrl']['fe_crgroup_id']) {
            $field = $GLOBALS['TCA'][$table]['ctrl']['fe_crgroup_id'];
            list($dataArr[$field]) = explode(',', $GLOBALS['TSFE']->fe_user->user['usergroup']);
            $dataArr[$field] = (int)$dataArr[$field];
            $extraList .= ',' . $field;
        }
        // Uid can never be set
        unset($dataArr['uid']);
        if ($pid >= 0) {
            $dataArr['pid'] = $pid;
        }
        // Set pid < 0 and the dataarr-pid will be used!
        $fieldList = implode(',', GeneralUtility::trimExplode(',', $fieldList . ',' . $extraList, TRUE));
        $insertFields = array();
        foreach ($dataArr as $f => $v) {
            if (GeneralUtility::inList($fieldList, $f)) {
                $insertFields[$f] = $v;
            }
        }
        if ($doExec) {
            return $GLOBALS['TYPO3_DB']->exec_INSERTquery($table, $insertFields);
        } else {
            return $GLOBALS['TYPO3_DB']->INSERTquery($table, $insertFields);
        }
    }

    public function DBmayFEUserEdit($table, $row, $feUserRow, $allowedGroups = '', $feEditSelf = 0) {
        $groupList = $allowedGroups ? implode(',', array_intersect(GeneralUtility::trimExplode(',', $feUserRow['usergroup'], TRUE), GeneralUtility::trimExplode(',', $allowedGroups, TRUE))) : $feUserRow['usergroup'];
        $ok = 0;
        // Points to the field that allows further editing from frontend if not set. If set the record is locked.
        if (!$GLOBALS['TCA'][$table]['ctrl']['fe_admin_lock'] || !$row[$GLOBALS['TCA'][$table]['ctrl']['fe_admin_lock']]) {
            // Points to the field (integer) that holds the fe_users-id of the creator fe_user
            if ($GLOBALS['TCA'][$table]['ctrl']['fe_cruser_id']) {
                $rowFEUser = (int)$row[$GLOBALS['TCA'][$table]['ctrl']['fe_cruser_id']];
                if ($rowFEUser && $rowFEUser == $feUserRow['uid']) {
                    $ok = 1;
                }
            }
            // If $feEditSelf is set, fe_users may always edit them selves...
            if ($feEditSelf && $table == 'fe_users' && (int)$feUserRow['uid'] === (int)$row['uid']) {
                $ok = 1;
            }
            // Points to the field (integer) that holds the fe_group-id of the creator fe_user's first group
            if ($GLOBALS['TCA'][$table]['ctrl']['fe_crgroup_id']) {
                $rowFEUser = (int)$row[$GLOBALS['TCA'][$table]['ctrl']['fe_crgroup_id']];
                if ($rowFEUser) {
                    if (GeneralUtility::inList($groupList, $rowFEUser)) {
                        $ok = 1;
                    }
                }
            }
        }
        return $ok;
    }

    public function DBmayFEUserEditSelect($table, $feUserRow, $allowedGroups = '', $feEditSelf = 0) {
        // Returns where-definition that selects user-editable records.
        $groupList = $allowedGroups ? implode(',', array_intersect(GeneralUtility::trimExplode(',', $feUserRow['usergroup'], TRUE), GeneralUtility::trimExplode(',', $allowedGroups, TRUE))) : $feUserRow['usergroup'];
        $OR_arr = array();
        // Points to the field (integer) that holds the fe_users-id of the creator fe_user
        if ($GLOBALS['TCA'][$table]['ctrl']['fe_cruser_id']) {
            $OR_arr[] = $GLOBALS['TCA'][$table]['ctrl']['fe_cruser_id'] . '=' . $feUserRow['uid'];
        }
        // Points to the field (integer) that holds the fe_group-id of the creator fe_user's first group
        if ($GLOBALS['TCA'][$table]['ctrl']['fe_crgroup_id']) {
            $values = GeneralUtility::intExplode(',', $groupList);
            foreach ($values as $theGroupUid) {
                if ($theGroupUid) {
                    $OR_arr[] = $GLOBALS['TCA'][$table]['ctrl']['fe_crgroup_id'] . '=' . $theGroupUid;
                }
            }
        }
        // If $feEditSelf is set, fe_users may always edit them selves...
        if ($feEditSelf && $table == 'fe_users') {
            $OR_arr[] = 'uid=' . (int)$feUserRow['uid'];
        }
        $whereDef = ' AND 1=0';
        if (count($OR_arr)) {
            $whereDef = ' AND (' . implode(' OR ', $OR_arr) . ')';
            if ($GLOBALS['TCA'][$table]['ctrl']['fe_admin_lock']) {
                $whereDef .= ' AND ' . $GLOBALS['TCA'][$table]['ctrl']['fe_admin_lock'] . '=0';
            }
        }
        return $whereDef;
    }

    public function enableFields($table, $show_hidden = FALSE, array $ignore_array = array()) {
        $show_hidden = $show_hidden ?: ($table === 'pages' ? $GLOBALS['TSFE']->showHiddenPage : $GLOBALS['TSFE']->showHiddenRecords);
        return $GLOBALS['TSFE']->sys_page->enableFields($table, $show_hidden, $ignore_array);
    }

    public function getTreeList($id, $depth, $begin = 0, $dontCheckEnableFields = FALSE, $addSelectFields = '', $moreWhereClauses = '', array $prevId_array = array(), $recursionLevel = 0) {
        $id = (int)$id;
        if (!$id) {
            return '';
        }

        // Init vars:
        $allFields = 'uid,hidden,starttime,endtime,fe_group,extendToSubpages,doktype,php_tree_stop,mount_pid,mount_pid_ol,t3ver_state' . $addSelectFields;
        $depth = (int)$depth;
        $begin = (int)$begin;
        $theList = array();
        $addId = 0;
        $requestHash = '';

        // First level, check id (second level, this is done BEFORE the recursive call)
        if (!$recursionLevel) {
            // Check tree list cache
            // First, create the hash for this request - not sure yet whether we need all these parameters though
            $parameters = array(
                $id,
                $depth,
                $begin,
                $dontCheckEnableFields,
                $addSelectFields,
                $moreWhereClauses,
                $prevId_array,
                $GLOBALS['TSFE']->gr_list
            );
            $requestHash = md5(serialize($parameters));
            $cacheEntry = $GLOBALS['TYPO3_DB']->exec_SELECTgetSingleRow(
                'treelist',
                'cache_treelist',
                'md5hash = \'' . $requestHash . '\' AND ( expires > ' . $GLOBALS['EXEC_TIME'] . ' OR expires = 0 )'
            );
            if (is_array($cacheEntry)) {
                // Cache hit
                return $cacheEntry['treelist'];
            }
            // If Id less than zero it means we should add the real id to list:
            if ($id < 0) {
                $addId = ($id = abs($id));
            }
            // Check start page:
            if ($GLOBALS['TSFE']->sys_page->getRawRecord('pages', $id, 'uid')) {
                // Find mount point if any:
                $mount_info = $GLOBALS['TSFE']->sys_page->getMountPointInfo($id);
                if (is_array($mount_info)) {
                    $id = $mount_info['mount_pid'];
                    // In Overlay mode, use the mounted page uid as added ID!:
                    if ($addId && $mount_info['overlay']) {
                        $addId = $id;
                    }
                }
            } else {
                // Return blank if the start page was NOT found at all!
                return '';
            }
        }
        // Add this ID to the array of IDs
        if ($begin <= 0) {
            $prevId_array[] = $id;
        }
        // Select sublevel:
        if ($depth > 0) {
            $rows = $GLOBALS['TYPO3_DB']->exec_SELECTgetRows(
                $allFields,
                'pages',
                'pid = ' . (int)$id . ' AND deleted = 0 ' . $moreWhereClauses,
                '',
                'sorting'
            );
            if (is_array($rows)) {
                foreach ($rows as $row) {
                    $versionState = VersionState::cast($row['t3ver_state']);
                    $GLOBALS['TSFE']->sys_page->versionOL('pages', $row);
                    if ($row['doktype'] == \TYPO3\CMS\Frontend\Page\PageRepository::DOKTYPE_RECYCLER
                        || $row['doktype'] == \TYPO3\CMS\Frontend\Page\PageRepository::DOKTYPE_BE_USER_SECTION
                        || $versionState->indicatesPlaceholder()
                    ) {
                        // Doing this after the overlay to make sure changes
                        // in the overlay are respected.
                        // However, we do not process pages below of and
                        // including of type recycler and BE user section
                        continue;
                    }
                    // Find mount point if any:
                    $next_id = $row['uid'];
                    $mount_info = $GLOBALS['TSFE']->sys_page->getMountPointInfo($next_id, $row);
                    // Overlay mode:
                    if (is_array($mount_info) && $mount_info['overlay']) {
                        $next_id = $mount_info['mount_pid'];
                        $row = $GLOBALS['TYPO3_DB']->exec_SELECTgetSingleRow(
                            $allFields,
                            'pages',
                            'uid = ' . (int)$next_id . ' AND deleted = 0 ' . $moreWhereClauses,
                            '',
                            'sorting'
                        );
                        $GLOBALS['TSFE']->sys_page->versionOL('pages', $row);
                        if ($row['doktype'] == \TYPO3\CMS\Frontend\Page\PageRepository::DOKTYPE_RECYCLER
                            || $row['doktype'] == \TYPO3\CMS\Frontend\Page\PageRepository::DOKTYPE_BE_USER_SECTION
                            || $versionState->indicatesPlaceholder()
                        ) {
                            // Doing this after the overlay to make sure
                            // changes in the overlay are respected.
                            // see above
                            continue;
                        }
                    }
                    // Add record:
                    if ($dontCheckEnableFields || $GLOBALS['TSFE']->checkPagerecordForIncludeSection($row)) {
                        // Add ID to list:
                        if ($begin <= 0) {
                            if ($dontCheckEnableFields || $GLOBALS['TSFE']->checkEnableFields($row)) {
                                $theList[] = $next_id;
                            }
                        }
                        // Next level:
                        if ($depth > 1 && !$row['php_tree_stop']) {
                            // Normal mode:
                            if (is_array($mount_info) && !$mount_info['overlay']) {
                                $next_id = $mount_info['mount_pid'];
                            }
                            // Call recursively, if the id is not in prevID_array:
                            if (!in_array($next_id, $prevId_array)) {
                                $theList = array_merge(
                                    GeneralUtility::intExplode(
                                        ',',
                                        $this->getTreeList($next_id, $depth - 1, $begin - 1,
                                            $dontCheckEnableFields, $addSelectFields, $moreWhereClauses,
                                            $prevId_array, $recursionLevel + 1),
                                        TRUE
                                    ),
                                    $theList
                                );
                            }
                        }
                    }
                }
            }
        }
        // If first run, check if the ID should be returned:
        if (!$recursionLevel) {
            if ($addId) {
                if ($begin > 0) {
                    $theList[] = 0;
                } else {
                    $theList[] = $addId;
                }
            }
            $GLOBALS['TYPO3_DB']->exec_INSERTquery('cache_treelist', array(
                'md5hash' => $requestHash,
                'pid' => $id,
                'treelist' => implode(',', $theList),
                'tstamp' => $GLOBALS['EXEC_TIME']
            ));
        }

        return implode(',', $theList);
    }

    public function exec_mm_query($select, $local_table, $mm_table, $foreign_table, $whereClause = '', $groupBy = '', $orderBy = '', $limit = '') {
        return $GLOBALS['TYPO3_DB']->exec_SELECTquery($select, $local_table . ',' . $mm_table . ($foreign_table ? ',' . $foreign_table : ''), $local_table . '.uid=' . $mm_table . '.uid_local' . ($foreign_table ? ' AND ' . $foreign_table . '.uid=' . $mm_table . '.uid_foreign' : '') . $whereClause, $groupBy, $orderBy, $limit);
    }

    public function exec_mm_query_uidList($select, $local_table_uidlist, $mm_table, $foreign_table = '', $whereClause = '', $groupBy = '', $orderBy = '', $limit = '') {
        return $GLOBALS['TYPO3_DB']->exec_SELECTquery($select, $mm_table . ($foreign_table ? ',' . $foreign_table : ''), $mm_table . '.uid_local IN (' . $local_table_uidlist . ')' . ($foreign_table ? ' AND ' . $foreign_table . '.uid=' . $mm_table . '.uid_foreign' : '') . $whereClause, $groupBy, $orderBy, $limit);
    }

    public function searchWhere($sw, $searchFieldList, $searchTable = '') {
        global $TYPO3_DB;
        $prefixTableName = $searchTable ? $searchTable . '.' : '';
        $where = '';
        if ($sw) {
            $searchFields = explode(',', $searchFieldList);
            $kw = preg_split('/[ ,]/', $sw);
            foreach ($kw as $val) {
                $val = trim($val);
                $where_p = array();
                if (strlen($val) >= 2) {
                    $val = $TYPO3_DB->escapeStrForLike($TYPO3_DB->quoteStr($val, $searchTable), $searchTable);
                    foreach ($searchFields as $field) {
                        $where_p[] = $prefixTableName . $field . ' LIKE \'%' . $val . '%\'';
                    }
                }
                if (count($where_p)) {
                    $where .= ' AND (' . implode(' OR ', $where_p) . ')';
                }
            }
        }
        return $where;
    }

    public function exec_getQuery($table, $conf) {
        $queryParts = $this->getQuery($table, $conf, TRUE);
        return $GLOBALS['TYPO3_DB']->exec_SELECT_queryArray($queryParts);
    }

    public function getQuery($table, $conf, $returnQueryArray = FALSE) {
        // Resolve stdWrap in these properties first
        $properties = array(
            'pidInList',
            'uidInList',
            'languageField',
            'selectFields',
            'max',
            'begin',
            'groupBy',
            'orderBy',
            'join',
            'leftjoin',
            'rightjoin',
            'recursive',
            'where'
        );
        foreach ($properties as $property) {
            $conf[$property] = isset($conf[$property . '.']) ? trim($this->stdWrap($conf[$property], $conf[$property . '.'])) : trim($conf[$property]);
            if ($conf[$property] === '') {
                unset($conf[$property]);
            }
            if (isset($conf[$property . '.'])) {
                // stdWrapping already done, so remove the sub-array
                unset($conf[$property . '.']);
            }
        }
        // Handle PDO-style named parameter markers first
        $queryMarkers = $this->getQueryMarkers($table, $conf);
        // Replace the markers in the non-stdWrap properties
        foreach ($queryMarkers as $marker => $markerValue) {
            $properties = array(
                'uidInList',
                'selectFields',
                'where',
                'max',
                'begin',
                'groupBy',
                'orderBy',
                'join',
                'leftjoin',
                'rightjoin'
            );
            foreach ($properties as $property) {
                if ($conf[$property]) {
                    $conf[$property] = str_replace('###' . $marker . '###', $markerValue, $conf[$property]);
                }
            }
        }
        // Construct WHERE clause:
        // Handle recursive function for the pidInList
        if (isset($conf['recursive'])) {
            $conf['recursive'] = (int)$conf['recursive'];
            if ($conf['recursive'] > 0) {
                $pidList = GeneralUtility::trimExplode(',', $conf['pidInList'], TRUE);
                array_walk($pidList, function (&$storagePid) {
                    if ($storagePid === 'this') {
                        $storagePid = $GLOBALS['TSFE']->id;
                    }
                    if ($storagePid > 0) {
                        $storagePid = -$storagePid;
                    }
                });
                $expandedPidList = array();
                foreach ($pidList as $value) {
                    // Implementation of getTreeList allows to pass the id negative to include
                    // it into the result otherwise only childpages are returned
                    $expandedPidList = array_merge(
                        GeneralUtility::intExplode(',', $this->getTreeList($value, $conf['recursive'])),
                        $expandedPidList
                    );
                }
                $conf['pidInList'] = implode(',', $expandedPidList);
            }
        }
        if ((string)$conf['pidInList'] === '') {
            $conf['pidInList'] = 'this';
        }
        $queryParts = $this->getWhere($table, $conf, TRUE);
        // Fields:
        if ($conf['selectFields']) {
            $queryParts['SELECT'] = $this->sanitizeSelectPart($conf['selectFields'], $table);
        } else {
            $queryParts['SELECT'] = '*';
        }
        // Setting LIMIT:
        if ($conf['max'] || $conf['begin']) {
            $error = 0;
            // Finding the total number of records, if used:
            if (strstr(strtolower($conf['begin'] . $conf['max']), 'total')) {
                $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('count(*)', $table, $queryParts['WHERE'], $queryParts['GROUPBY']);
                if ($error = $GLOBALS['TYPO3_DB']->sql_error()) {
                    $GLOBALS['TT']->setTSlogMessage($error);
                } else {
                    $row = $GLOBALS['TYPO3_DB']->sql_fetch_row($res);
                    $conf['max'] = str_ireplace('total', $row[0], $conf['max']);
                    $conf['begin'] = str_ireplace('total', $row[0], $conf['begin']);
                }
                $GLOBALS['TYPO3_DB']->sql_free_result($res);
            }
            if (!$error) {
                $conf['begin'] = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange(ceil($this->calc($conf['begin'])), 0);
                $conf['max'] = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange(ceil($this->calc($conf['max'])), 0);
                if ($conf['begin'] && !$conf['max']) {
                    $conf['max'] = 100000;
                }
                if ($conf['begin'] && $conf['max']) {
                    $queryParts['LIMIT'] = $conf['begin'] . ',' . $conf['max'];
                } elseif (!$conf['begin'] && $conf['max']) {
                    $queryParts['LIMIT'] = $conf['max'];
                }
            }
        }
        if (!$error) {
            // Setting up tablejoins:
            $joinPart = '';
            if ($conf['join']) {
                $joinPart = 'JOIN ' . $conf['join'];
            } elseif ($conf['leftjoin']) {
                $joinPart = 'LEFT OUTER JOIN ' . $conf['leftjoin'];
            } elseif ($conf['rightjoin']) {
                $joinPart = 'RIGHT OUTER JOIN ' . $conf['rightjoin'];
            }
            // Compile and return query:
            $queryParts['FROM'] = trim($table . ' ' . $joinPart);
            // Replace the markers in the queryParts to handle stdWrap
            // enabled properties
            foreach ($queryMarkers as $marker => $markerValue) {
                foreach ($queryParts as $queryPartKey => &$queryPartValue) {
                    $queryPartValue = str_replace('###' . $marker . '###', $markerValue, $queryPartValue);
                }
                unset($queryPartValue);
            }
            $query = $GLOBALS['TYPO3_DB']->SELECTquery($queryParts['SELECT'], $queryParts['FROM'], $queryParts['WHERE'], $queryParts['GROUPBY'], $queryParts['ORDERBY'], $queryParts['LIMIT']);
            return $returnQueryArray ? $queryParts : $query;
        }
    }

    public function getWhere($table, $conf, $returnQueryArray = FALSE) {
        // Init:
        $query = '';
        $pid_uid_flag = 0;
        $enableFieldsIgnore = array();
        $queryParts = array(
            'SELECT' => '',
            'FROM' => '',
            'WHERE' => '',
            'GROUPBY' => '',
            'ORDERBY' => '',
            'LIMIT' => ''
        );
        $considerMovePlaceholders = (
            $GLOBALS['TSFE']->sys_page->versioningPreview && $table !== 'pages'
            && !empty($GLOBALS['TCA'][$table]['ctrl']['versioningWS'])
            && (int)$GLOBALS['TCA'][$table]['ctrl']['versioningWS'] >= 2
        );
        if (trim($conf['uidInList'])) {
            $listArr = GeneralUtility::intExplode(',', str_replace('this', $GLOBALS['TSFE']->contentPid, $conf['uidInList']));
            if (count($listArr) === 1) {
                $comparison = '=' . (int)$listArr[0];
            } else {
                $comparison = ' IN (' . implode(',', $GLOBALS['TYPO3_DB']->cleanIntArray($listArr)) . ')';
            }
            // If move placeholder shall be considered, select via t3ver_move_id
            if ($considerMovePlaceholders) {
                $movePlaceholderComparison = $table . '.t3ver_state=' . VersionState::cast(VersionState::MOVE_PLACEHOLDER) .  ' AND ' . $table . '.t3ver_move_id' . $comparison;
                $query .= ' AND (' . $table . '.uid' . $comparison . ' OR ' . $movePlaceholderComparison .')';
            } else {
                $query .= ' AND ' . $table . '.uid' . $comparison;
            }
            $pid_uid_flag++;
        }
        // Static_* tables are allowed to be fetched from root page
        if (substr($table, 0, 7) == 'static_') {
            $pid_uid_flag++;
        }
        if (trim($conf['pidInList'])) {
            $listArr = GeneralUtility::intExplode(',', str_replace('this', $GLOBALS['TSFE']->contentPid, $conf['pidInList']));
            // Removes all pages which are not visible for the user!
            $listArr = $this->checkPidArray($listArr);
            if (GeneralUtility::inList($conf['pidInList'], 'root')) {
                $listArr[] = 0;
            }
            if (GeneralUtility::inList($conf['pidInList'], '-1')) {
                $listArr[] = -1;
                $enableFieldsIgnore['pid'] = TRUE;
            }
            if (count($listArr)) {
                $query .= ' AND ' . $table . '.pid IN (' . implode(',', array_map('intval', $listArr)) . ')';
                $pid_uid_flag++;
            } else {
                // If not uid and not pid then uid is set to 0 - which results in nothing!!
                $pid_uid_flag = 0;
            }
        }
        // If not uid and not pid then uid is set to 0 - which results in nothing!!
        if (!$pid_uid_flag) {
            $query .= ' AND ' . $table . '.uid=0';
        }
        $where = isset($conf['where.']) ? trim($this->stdWrap($conf['where'], $conf['where.'])) : trim($conf['where']);
        if ($where) {
            $query .= ' AND ' . $where;
        }
        if ($conf['languageField']) {
            // The sys_language record UID of the content of the page
            $sys_language_content = (int)$GLOBALS['TSFE']->sys_language_content;

            if ($GLOBALS['TSFE']->sys_language_contentOL
                && isset($GLOBALS['TCA'][$table])
                && !empty($GLOBALS['TCA'][$table]['ctrl']['languageField'])
                && !empty($GLOBALS['TCA'][$table]['ctrl']['transOrigPointerField'])
            ) {
                // Sys language content is set to zero/-1 - and it is expected that whatever routine processes the output will
                // OVERLAY the records with localized versions!
                $languageQuery = $conf['languageField'] . ' IN (0,-1)';
                // Use this option to include records that don't have a default translation
                // (originalpointerfield is 0 and the language field contains the requested language)
                if (!empty($conf['includeRecordsWithoutDefaultTranslation'])) {
                    $languageQuery .= ' OR (' . $GLOBALS['TCA'][$table]['ctrl']['transOrigPointerField'] . ' = 0 AND ' .
                        $conf['languageField'] . ' = ' . $sys_language_content . ')';
                }
            } else {
                $languageQuery = $conf['languageField'] . ' = ' . $sys_language_content;
            }
            $query .= ' AND (' . $languageQuery . ')';
        }
        $andWhere = isset($conf['andWhere.']) ? trim($this->stdWrap($conf['andWhere'], $conf['andWhere.'])) : trim($conf['andWhere']);
        if ($andWhere) {
            $query .= ' AND ' . $andWhere;
        }
        // Enablefields
        if ($table == 'pages') {
            $query .= ' ' . $GLOBALS['TSFE']->sys_page->where_hid_del . $GLOBALS['TSFE']->sys_page->where_groupAccess;
        } else {
            $query .= $this->enableFields($table, FALSE, $enableFieldsIgnore);
        }
        // MAKE WHERE:
        if ($query) {
            // Stripping of " AND"...
            $queryParts['WHERE'] = trim(substr($query, 4));
            $query = 'WHERE ' . $queryParts['WHERE'];
        }
        // GROUP BY
        if (trim($conf['groupBy'])) {
            $queryParts['GROUPBY'] = isset($conf['groupBy.']) ? trim($this->stdWrap($conf['groupBy'], $conf['groupBy.'])) : trim($conf['groupBy']);
        }
        // ORDER BY
        if (trim($conf['orderBy'])) {
            $queryParts['ORDERBY'] = isset($conf['orderBy.']) ? trim($this->stdWrap($conf['orderBy'], $conf['orderBy.'])) : trim($conf['orderBy']);
            $query .= ' ORDER BY ' . $queryParts['ORDERBY'];
        }
        // Return result:
        return $returnQueryArray ? $queryParts : $query;
    }

    protected function sanitizeSelectPart($selectPart, $table) {
        // Pattern matching parts
        $matchStart = '/(^\\s*|,\\s*|' . $table . '\\.)';
        $matchEnd = '(\\s*,|\\s*$)/';
        $necessaryFields = array('uid', 'pid');
        $wsFields = array('t3ver_state');
        if (isset($GLOBALS['TCA'][$table]) && !preg_match(($matchStart . '\\*' . $matchEnd), $selectPart) && !preg_match('/(count|max|min|avg|sum)\\([^\\)]+\\)/i', $selectPart)) {
            foreach ($necessaryFields as $field) {
                $match = $matchStart . $field . $matchEnd;
                if (!preg_match($match, $selectPart)) {
                    $selectPart .= ', ' . $table . '.' . $field . ' as ' . $field;
                }
            }
            if ($GLOBALS['TCA'][$table]['ctrl']['versioningWS']) {
                foreach ($wsFields as $field) {
                    $match = $matchStart . $field . $matchEnd;
                    if (!preg_match($match, $selectPart)) {
                        $selectPart .= ', ' . $table . '.' . $field . ' as ' . $field;
                    }
                }
            }
        }
        return $selectPart;
    }

    public function checkPidArray($listArr) {
        $outArr = array();
        if (is_array($listArr) && count($listArr)) {
            $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('uid', 'pages', 'uid IN (' . implode(',', $listArr) . ')' . $this->enableFields('pages') . ' AND doktype NOT IN (' . $this->checkPid_badDoktypeList . ')');
            if ($error = $GLOBALS['TYPO3_DB']->sql_error()) {
                $GLOBALS['TT']->setTSlogMessage($error . ': ' . $GLOBALS['TYPO3_DB']->debug_lastBuiltQuery, 3);
            } else {
                while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                    $outArr[] = $row['uid'];
                }
            }
            $GLOBALS['TYPO3_DB']->sql_free_result($res);
        }
        return $outArr;
    }

    public function checkPid($uid) {
        $uid = (int)$uid;
        if (!isset($this->checkPid_cache[$uid])) {
            $count = $GLOBALS['TYPO3_DB']->exec_SELECTcountRows('uid', 'pages', 'uid=' . $uid . $this->enableFields('pages') . ' AND doktype NOT IN (' . $this->checkPid_badDoktypeList . ')');
            $this->checkPid_cache[$uid] = (bool) $count;
        }
        return $this->checkPid_cache[$uid];
    }

    public function getQueryMarkers($table, $conf) {
        // Parse markers and prepare their values
        $markerValues = array();
        if (is_array($conf['markers.'])) {
            foreach ($conf['markers.'] as $dottedMarker => $dummy) {
                $marker = rtrim($dottedMarker, '.');
                if ($dottedMarker == $marker . '.') {
                    // Parse definition
                    $tempValue = isset($conf['markers.'][$dottedMarker]) ? $this->stdWrap($conf['markers.'][$dottedMarker]['value'], $conf['markers.'][$dottedMarker]) : $conf['markers.'][$dottedMarker]['value'];
                    // Quote/escape if needed
                    if (is_numeric($tempValue)) {
                        if ((int)$tempValue == $tempValue) {
                            // Handle integer
                            $markerValues[$marker] = (int)$tempValue;
                        } else {
                            // Handle float
                            $markerValues[$marker] = floatval($tempValue);
                        }
                    } elseif (is_null($tempValue)) {
                        // It represents NULL
                        $markerValues[$marker] = 'NULL';
                    } elseif ($conf['markers.'][$dottedMarker]['commaSeparatedList'] == 1) {
                        // See if it is really a comma separated list of values
                        $explodeValues = GeneralUtility::trimExplode(',', $tempValue);
                        if (count($explodeValues) > 1) {
                            // Handle each element of list separately
                            $tempArray = array();
                            foreach ($explodeValues as $listValue) {
                                if (is_numeric($listValue)) {
                                    if ((int)$listValue == $listValue) {
                                        $tempArray[] = (int)$listValue;
                                    } else {
                                        $tempArray[] = floatval($listValue);
                                    }
                                } else {
                                    // If quoted, remove quotes before
                                    // escaping.
                                    if (preg_match('/^\'([^\']*)\'$/', $listValue, $matches)) {
                                        $listValue = $matches[1];
                                    } elseif (preg_match('/^\\"([^\\"]*)\\"$/', $listValue, $matches)) {
                                        $listValue = $matches[1];
                                    }
                                    $tempArray[] = $GLOBALS['TYPO3_DB']->fullQuoteStr($listValue, $table);
                                }
                            }
                            $markerValues[$marker] = implode(',', $tempArray);
                        } else {
                            // Handle remaining values as string
                            $markerValues[$marker] = $GLOBALS['TYPO3_DB']->fullQuoteStr($tempValue, $table);
                        }
                    } else {
                        // Handle remaining values as string
                        $markerValues[$marker] = $GLOBALS['TYPO3_DB']->fullQuoteStr($tempValue, $table);
                    }
                }
            }
        }
        return $markerValues;
    }

    /***********************************************
     *
     * Frontend editing functions
     *
     ***********************************************/
    public function editPanel($content, $conf, $currentRecord = '', $dataArr = array()) {
        if ($GLOBALS['TSFE']->beUserLogin && $GLOBALS['BE_USER']->frontendEdit instanceof \TYPO3\CMS\Core\FrontendEditing\FrontendEditingController) {
            if (!$currentRecord) {
                $currentRecord = $this->currentRecord;
            }
            if (!count($dataArr)) {
                $dataArr = $this->data;
            }
            // Delegate rendering of the edit panel to the frontend edit
            $content = $GLOBALS['BE_USER']->frontendEdit->displayEditPanel($content, $conf, $currentRecord, $dataArr);
        }
        return $content;
    }

    public function editIcons($content, $params, array $conf = array(), $currentRecord = '', $dataArr = array(), $addUrlParamStr = '') {
        if ($GLOBALS['TSFE']->beUserLogin && $GLOBALS['BE_USER']->frontendEdit instanceof \TYPO3\CMS\Core\FrontendEditing\FrontendEditingController) {
            if (!$currentRecord) {
                $currentRecord = $this->currentRecord;
            }
            if (!count($dataArr)) {
                $dataArr = $this->data;
            }
            // Delegate rendering of the edit panel to frontend edit class.
            $content = $GLOBALS['BE_USER']->frontendEdit->displayEditIcons($content, $params, $conf, $currentRecord, $dataArr, $addUrlParamStr);
        }
        return $content;
    }

    public function isDisabled($table, $row) {
        if ($GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['disabled'] && $row[$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['disabled']] || $GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['fe_group'] && $GLOBALS['TSFE']->simUserGroup && $row[$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['fe_group']] == $GLOBALS['TSFE']->simUserGroup || $GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['starttime'] && $row[$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['starttime']] > $GLOBALS['EXEC_TIME'] || $GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['endtime'] && $row[$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['endtime']] && $row[$GLOBALS['TCA'][$table]['ctrl']['enablecolumns']['endtime']] < $GLOBALS['EXEC_TIME']) {
            return TRUE;
        }
    }

    protected function getResourceFactory() {
        return \TYPO3\CMS\Core\Resource\ResourceFactory::getInstance();
    }

    protected function getEnvironmentVariable($key) {
        return GeneralUtility::getIndpEnv($key);
    }
}