class.t3lib_tstemplate.php

Go to the documentation of this file.

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2004 Kasper Skaarhoj (kasperYYYY@typo3.com)
*  All rights reserved
*
*  This script is part of the TYPO3 project. The TYPO3 project is
*  free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  The GNU General Public License can be found at
*  http://www.gnu.org/copyleft/gpl.html.
*  A copy is found in the textfile GPL.txt and important notices to the license
*  from the author is found in LICENSE.txt distributed with these scripts.
*
*
*  This script is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  This copyright notice MUST APPEAR in all copies of the script!
***************************************************************/
require_once (PATH_t3lib.'class.t3lib_tsparser.php');
require_once (PATH_t3lib.'class.t3lib_matchcondition.php');
















class t3lib_TStemplate  {

      // Debugging, analysis:
   var $tt_track = 1;               // If set, the global tt-timeobject is used to log the performance.
   var $forceTemplateParsing=0;     // If set, the template is always rendered. Used from Admin Panel.

      // Backend Analysis modules settings:
   var $matchAlternative=array();      // This array is passed on to matchObj by generateConfig(). If it holds elements, they are used for matching instead. See commment at the match-class. Used for backend modules only. Never frontend!
   var $matchAll=0;              // If set, the match-class matches everything! Used for backend modules only. Never frontend!
   var $parseEditorCfgField=0;         // If set, the Backend Editor Configuration TypoScript is also parsed (this is not needed for the frontend)
   var $backend_info = 0;
   var $getFileName_backPath='';    // Set from the backend - used to set an absolute path (PATH_site) so that relative resources are properly found with getFileName()

      // Externally set breakpoints (used by Backend Modules)
   var $ext_constants_BRP=0;
   var $ext_config_BRP=0;
   var $ext_editorcfg_BRP=0;
   var $ext_regLinenumbers=FALSE;

      // Constants:
   var $uplPath = 'uploads/tf/';
   var $tempPath = 'typo3temp/';
   var $menuclasses = 'gmenu,tmenu,imgmenu,jsmenu';

      // Set Internally:
   var $whereClause = '';           // This MUST be initialized by the init() function
   var $debug = 0;
   var $allowedPaths = array();     // This is the only paths (relative!!) that are allowed for resources in TypoScript. Should all be appended with '/'. You can extend these by the global array TYPO3_CONF_VARS. See init() function.
   var $currentPageData = '';       // Contains "currentPageData" when rendered/fetched from cache. See getCurrentPageData()
   var $simulationHiddenOrTime=0;      // See init(); Set if preview of some kind is enabled.

   var $loaded = 0;              // Set, if the TypoScript template structure is loaded and OK, see ->start()
   var $setup = Array(              // Default TypoScript Setup code
      'styles.' => Array (
         'insertContent' => 'CONTENT',
         'insertContent.' => Array (
            'table' => 'tt_content',
            'select.' => Array (
               'orderBy' => 'sorting',
               'where' => 'colPos=0',
               'languageField' => 'sys_language_uid'
            )
         )
      ),
      'config.' => Array (
         'extTarget' => '_top',
         'stat' => 1,
         'stat_typeNumList' => '0,1'
      )
   );
   var $flatSetup = Array (
   );
   var $const = Array ( // Default TypoScript Constants code:
      '_clear' => '<img src="clear.gif" width="1" height="1" alt="" />',
      '_blackBorderWrap' => '<table border="0" bgcolor="black" cellspacing="0" cellpadding="1"><tr><td> | </td></tr></table>',
      '_tableWrap' => '<table border="0" cellspacing="0" cellpadding="0"> | </table>',
      '_tableWrap_DEBUG' => '<table border="1" cellspacing="0" cellpadding="0"> | </table>',
      '_stdFrameParams' => 'frameborder="no" marginheight="0" marginwidth="0" noresize="noresize"',
      '_stdFramesetParams' => 'border="0" framespacing="0" frameborder="no"'
   );


      // For fetching TypoScript code from template hierarchy before parsing it. Each array contains code field values from template records/files:
   var $config = array();           // Setup field
   var $constants = array();        // Constant field
   var $editorcfg = array();        // Backend Editor Configuration field

   var $hierarchyInfo = array();    // For Template Analyser in backend
   var $hierarchyInfoToRoot = array();    // For Template Analyser in backend (setup content only)
   var $nextLevel=0;             // Next-level flag (see runThroughTemplates())
   var $rootId;                  // The Page UID of the root page
   var $rootLine;                // The rootline from current page to the root page
   var $absoluteRootLine;           // Rootline all the way to the root. Set but runThroughTemplates
   var $outermostRootlineIndexWithTemplate=0;   // A pointer to the last entry in the rootline where a template was found.
   var $rowSum;                  // Array of arrays with title/uid of templates in hierarchy
   var $resources='';               // Resources for the template hierarchy in a comma list
   var $sitetitle='';               // The current site title field.
   var $sections;                // Tracking all conditions found during parsing of TypoScript. Used for the "all" key in currentPageData
   var $sectionsMatch;              // Tracking all matching conditions found

      // Backend: ts_analyzer
   var $clearList_const=array();
   var $clearList_setup=array();
   var $clearList_editorcfg=array();
   var $parserErrors=array();
   var $setup_constants = array();

      // Other:
   var $fileCache = Array();        // Used by getFileName for caching of references to file resources
   var $frames = Array();           // Keys are frame names and values are type-values, which must be used to refer correctly to the content of the frames.
   var $MPmap = '';              // Contains mapping of Page id numbers to MP variables.




   function init()   {
         // $this->whereClause is used only to select templates from sys_template.
         // $GLOBALS['SIM_EXEC_TIME'] is used so that we're able to simulate a later time as a test...
      $this->whereClause='AND deleted=0 ';
      if (!$GLOBALS['TSFE']->showHiddenRecords) {
         $this->whereClause.='AND hidden=0 ';
      }
      if ($GLOBALS['TSFE']->showHiddenRecords || $GLOBALS['SIM_EXEC_TIME']!=$GLOBALS['EXEC_TIME']) {  // Set the simulation flag, if simulation is detected!
         $this->simulationHiddenOrTime=1;
      }
      $this->whereClause.= 'AND (starttime<='.$GLOBALS['SIM_EXEC_TIME'].') AND (endtime=0 OR endtime>'.$GLOBALS['SIM_EXEC_TIME'].')';
      if (!$GLOBALS['TYPO3_CONF_VARS']['GFX']['gdlib'])  {
         $this->menuclasses='tmenu,jsmenu,gmenu';
      }

         // Sets the paths from where TypoScript resources are allowed to be used:
      $this->allowedPaths = Array ('media/','fileadmin/','uploads/','typo3temp/','t3lib/fonts/',TYPO3_mainDir.'ext/',TYPO3_mainDir.'sysext/','typo3conf/ext/');
      if ($GLOBALS['TYPO3_CONF_VARS']['FE']['addAllowedPaths'])   {
         $pathArr = t3lib_div::trimExplode(',',$GLOBALS['TYPO3_CONF_VARS']['FE']['addAllowedPaths'],1);
         while(list(,$p)=each($pathArr))  {
               // Once checked for path, but as this may run from typo3/mod/web/ts/ dir, that'll not work!! So the paths ar uncritically included here.
            $this->allowedPaths[] = $p;
         }
      }
   }

   function getCurrentPageData() {
      $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('content', 'cache_pagesection', 'page_id='.intval($GLOBALS['TSFE']->id).' AND mpvar_hash='.t3lib_div::md5int($GLOBALS['TSFE']->MP));
      if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
         $this->currentPageData = unserialize($row['content']);
      } else {
         $this->currentPageData = 'none';
      }
      return $this->currentPageData;
   }

   function matching($cc)  {
      if (is_array($cc['all']))  {
         reset($cc['all']);
         $matchObj = t3lib_div::makeInstance('t3lib_matchCondition');
         $matchObj->altRootLine=$cc['rootLine'];
         while(list($key,$pre)=each($cc['all']))   {
            if ($matchObj->match($pre))   {
               $sectionsMatch[$key]=$pre;
            }
         }
         $cc['match']=$sectionsMatch;
      }
      return $cc;
   }

   function start($theRootLine)  {
      if (is_array($theRootLine))   {
         $setupData='';
         $cc=Array();
         $hash='';
         $this->runThroughTemplates($theRootLine);

            // Getting the currentPageData if not already found
         if (!$this->currentPageData)  {
            $this->getCurrentPageData();
         }

            // This is about getting the hash string which is used to fetch the cached TypoScript template.
            // If there was some cached currentPageData that's good (it gives us the hash),
            // However if the actual rowSum and the rowSum of currentPageData is different from each other, thats a problem, and we should re-make the current page data.
         if (is_array($this->currentPageData) &&
            !strcmp(serialize($this->rowSum), serialize($this->currentPageData['rowSum']))   // The two ROWsums must NOT be different from each other - which they will be if start/endtime or hidden has changed!
         )  {
               // If currentPageData was actually there, we match the result...
            $cc['all'] = $this->currentPageData['all'];
            $cc['rowSum'] = $this->currentPageData['rowSum'];
            $cc = $this->matching($cc);
            $hash = md5(serialize($cc));
         } else {
               // If currentPageData was not there, we first find $rowSum (freshly generated). After that we try to see, if rowSum is stored with a list of all matching-parameters. If so we match the result
            $rowSumHash = md5('ROWSUM:'.serialize($this->rowSum));
            $result = t3lib_pageSelect::getHash($rowSumHash, 0);
            if ($result)   {
               $cc['all'] = unserialize($result);
               $cc['rowSum'] = $this->rowSum;
               $cc = $this->matching($cc);
               $hash = md5(serialize($cc));
            }
         }

         if ($hash)  {
               // Get TypoScript setup array
            $setupData = t3lib_pageSelect::getHash($hash, 0);
         }

         if ($hash && $setupData && !$this->forceTemplateParsing)    {
               // If TypoScript setup structure was cached we unserialize it here:
            $this->setup = unserialize($setupData);
         } else {
               // Make configuration
            $this->generateConfig();

               // This stores the template hash thing
            $cc=Array();
            $cc['all']=$this->sections;   // All sections in the template at this point is found
            $cc['rowSum']=$this->rowSum;  // The line of templates is collected
            $cc = $this->matching($cc);

            $hash = md5(serialize($cc));

               // This stores the data.
            t3lib_pageSelect::storeHash($hash, serialize($this->setup), 'TS TEMPLATE');

            if ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('TS template size, serialized: '.strlen(serialize($this->setup)).' bytes');

            $rowSumHash = md5('ROWSUM:'.serialize($this->rowSum));
            t3lib_pageSelect::storeHash($rowSumHash, serialize($cc['all']), 'TMPL CONDITIONS - ALL');
         }
            // Add rootLine
         $cc['rootLine'] = $this->rootLine;
            // Make global and save.
         $GLOBALS['TSFE']->all=$cc;

         if (!$this->simulationHiddenOrTime) {  // Only save currentPageData, if we're not simulating by hidden/starttime/endtime
            $insertFields = array(
               'page_id' => intval($GLOBALS['TSFE']->id),
               'mpvar_hash' => t3lib_div::md5int($GLOBALS['TSFE']->MP),
               'content' => serialize($cc),
               'tstamp' => $GLOBALS['EXEC_TIME']
            );
            $GLOBALS['TYPO3_DB']->exec_DELETEquery('cache_pagesection', 'page_id='.intval($GLOBALS['TSFE']->id).' AND mpvar_hash='.t3lib_div::md5int($GLOBALS['TSFE']->MP));
            $GLOBALS['TYPO3_DB']->exec_INSERTquery('cache_pagesection', $insertFields);
         }
            // If everything OK.
         if ($this->rootId && $this->rootLine && $this->setup) {
            $this->loaded = 1;
         }
      }
   }















   /*******************************************************************
    *
    * Fetching TypoScript code text for the Template Hierarchy
    *
    *******************************************************************/

   function runThroughTemplates($theRootLine,$start_template_uid=0)  {
      $this->constants = Array();
      $this->config = Array();
      $this->editorcfg = Array();
      $this->rowSum = Array();
      $this->hierarchyInfoToRoot = Array();
      $this->absoluteRootLine=$theRootLine;  // Is the TOTAL rootline

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

         $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'sys_template', 'pid='.intval($this->absoluteRootLine[$a]['uid']).$addC.' '.$this->whereClause,'','sorting',1);
         if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {
            $this->processTemplate($row,'sys_'.$row['uid'],$this->absoluteRootLine[$a]['uid'],'sys_'.$row['uid']);
            $this->outermostRootlineIndexWithTemplate=$a;
         }
         $GLOBALS['TYPO3_DB']->sql_free_result($res);
         $this->rootLine[] = $this->absoluteRootLine[$a];
      }
   }

   function processTemplate($row, $idList,$pid,$templateID='',$templateParent='')   {
         // Adding basic template record information to rowSum array
      $this->rowSum[]=Array($row['uid'],$row['title'],$row['tstamp']);

         // Processing "Clear"-flags
      if ($row['clear'])   {
         $clConst = $row['clear']&1;
         $clConf = $row['clear']&2;
         if ($clConst)  {
            $this->constants = Array();
            $this->clearList_const=array();
         }
         if ($clConf)   {
            $this->config = Array();
            $this->hierarchyInfoToRoot = Array();
            $this->clearList_setup=array();

            $this->editorcfg = Array();
            $this->clearList_editorcfg=array();
         }
      }

         // Include static records (static_template) or files (from extensions) (#1/2)
      if (!$row['includeStaticAfterBasedOn'])      {     // NORMAL inclusion, The EXACT same code is found below the basedOn inclusion!!!
         $this->includeStaticTypoScriptSources($idList,$templateID,$pid,$row);
      }

         // Include "Based On" sys_templates:
      if (trim($row['basedOn'])) {     // 'basedOn' is a list of templates to include
            // Manually you can put this value in the field and then the based_on ID will be taken from the $_GET var defined by '=....'.
            // Example: If $row['basedOn'] is 'EXTERNAL_BASED_ON_TEMPLATE_ID=based_on_uid', then the global var, based_on_uid - given by the URL like '&based_on_uid=999' - is included instead!
            // This feature allows us a hack to test/demonstrate various included templates on the same set of content bearing pages. Used by the "freesite" extension.
         $basedOn_hackFeature = explode('=',$row['basedOn']);
         if ($basedOn_hackFeature[0]=='EXTERNAL_BASED_ON_TEMPLATE_ID' && $basedOn_hackFeature[1])     {
            $id = intval(t3lib_div::_GET($basedOn_hackFeature[1]));
            if ($id && !t3lib_div::inList($idList,'sys_'.$id)) {  // if $id is not allready included ...
               $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'sys_template', 'uid='.$id.' '.$this->whereClause);
               if ($subrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {  // there was a template, then we fetch that
                  $this->processTemplate($subrow,$idList.',sys_'.$id,$pid, 'sys_'.$id,$templateID);
               }
               $GLOBALS['TYPO3_DB']->sql_free_result($res);
            }
         } else { // NORMAL OPERATION:
            $basedOnArr = t3lib_div::intExplode(',',$row['basedOn']);
            while(list(,$id)=each($basedOnArr)) {  // traversing list
               if (!t3lib_div::inList($idList,'sys_'.$id))  {  // if $id is not allready included ...
                  $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'sys_template', 'uid='.intval($id).' '.$this->whereClause);
                  if ($subrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {  // there was a template, then we fetch that
                     $this->processTemplate($subrow,$idList.',sys_'.$id,$pid, 'sys_'.$id,$templateID);
                  }
                  $GLOBALS['TYPO3_DB']->sql_free_result($res);
               }
            }
         }
      }

         // Include static records (static_template) or files (from extensions) (#2/2)
      if ($row['includeStaticAfterBasedOn'])    {
         $this->includeStaticTypoScriptSources($idList,$templateID,$pid,$row);
      }

         // Creating hierarchy information; Used by backend analysis tools
      $this->hierarchyInfo[] = $this->hierarchyInfoToRoot[] = array(
         'root'=>trim($row['root']),
         'next'=>$row['nextLevel'],
         'clConst'=>$clConst,
         'clConf'=>$clConf,
         'templateID'=>$templateID,
         'templateParent'=>$templateParent,
         'title'=>$row['title'],
         'uid'=>$row['uid'],
         'pid'=>$row['pid'],
         'configLines' => substr_count($row['config'], chr(10))+1
      );

         // Adding the content of the fields constants (Constants), config (Setup) and editorcfg (Backend Editor Configuration) to the internal arrays.
      $this->constants[] = $row['constants'];
      $this->config[] = $row['config'];
      if ($this->parseEditorCfgField)     $this->editorcfg[] = $row['editorcfg'];

         // For backend analysis (Template Analyser) provide the order of added constants/config/editorcfg template IDs
      $this->clearList_const[]=$templateID;
      $this->clearList_setup[]=$templateID;
      if ($this->parseEditorCfgField)     $this->clearList_editorcfg[]=$templateID;

         // Add resources and sitetitle if found:
      if (trim($row['resources']))  {
         $this->resources = $row['resources'].','.$this->resources;
      }
      if (trim($row['sitetitle']))  {
         $this->sitetitle = $row['sitetitle'];
      }
         // If the template record is a Rootlevel record, set the flag and clear the template rootLine (so it starts over from this point)
      if (trim($row['root'])) {
         $this->rootId = $pid;
         $this->rootLine = Array();
      }
         // If a template is set to be active on the next level set this internal value to point to this UID. (See runThroughTemplates())
      if ($row['nextLevel'])  {
         $this->nextLevel = $row['nextLevel'];
      } else {
         $this->nextLevel = 0;
      }
   }

   function includeStaticTypoScriptSources($idList,$templateID,$pid,$row)  {
         // Static Template Records (static_template): include_static is a list of static templates to include
      if (trim($row['include_static']))   {
         $include_staticArr = t3lib_div::intExplode(',',$row['include_static']);
         reset($include_staticArr);
         while(list(,$id)=each($include_staticArr))   {  // traversing list
            if (!t3lib_div::inList($idList,'static_'.$id))  {  // if $id is not allready included ...
               $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'static_template', 'uid='.intval($id));
               if ($subrow = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {  // there was a template, then we fetch that
                  $subrow = $this->prependStaticExtra($subrow);
                  $this->processTemplate($subrow,$idList.',static_'.$id,$pid,'static_'.$id,$templateID);
               }
               $GLOBALS['TYPO3_DB']->sql_free_result($res);
            }
         }
      }

         // Static Template Files (Text files from extensions): include_static_file is a list of static files to include (from extensions)
      if (trim($row['include_static_file'])) {
         $include_static_fileArr = t3lib_div::trimExplode(',',$row['include_static_file'],1);
         reset($include_static_fileArr);
         while(list(,$ISF_file)=each($include_static_fileArr)) {  // traversing list
            $ISF_file = trim($ISF_file);
            if (substr($ISF_file,0,4)=='EXT:')  {
               list($ISF_extKey,$ISF_localPath) = explode('/',substr($ISF_file,4),2);
               if (strcmp($ISF_extKey,'') && t3lib_extMgm::isLoaded($ISF_extKey) && strcmp($ISF_localPath,'')) {
                  $ISF_localPath = ereg_replace('\/$','',$ISF_localPath).'/';
                  $ISF_filePath = t3lib_extMgm::extPath($ISF_extKey).$ISF_localPath;
                  if (@is_dir($ISF_filePath))   {
                     $mExtKey = str_replace('_','',$ISF_extKey.'/'.$ISF_localPath);
                     $subrow=array(
                        'constants'=>  @is_file($ISF_filePath.'constants.txt')   ?t3lib_div::getUrl($ISF_filePath.'constants.txt'):'',
                        'config'=>     @is_file($ISF_filePath.'setup.txt')    ?t3lib_div::getUrl($ISF_filePath.'setup.txt'):'',
                        'editorcfg'=>  @is_file($ISF_filePath.'editorcfg.txt')   ?t3lib_div::getUrl($ISF_filePath.'editorcfg.txt'):'',
                        'include_static'=>   @is_file($ISF_filePath.'include_static.txt')?implode(',',array_unique(t3lib_div::intExplode(',',t3lib_div::getUrl($ISF_filePath.'include_static.txt')))):'',
                        'title' =>     $ISF_file,
                        'uid' =>       $mExtKey
                     );
                     $subrow = $this->prependStaticExtra($subrow);

                     $this->processTemplate($subrow,$idList.',ext_'.$mExtKey,$pid, 'ext_'.$mExtKey,$templateID);
                  }
               }
            }
         }
      }

      $this->addExtensionStatics($idList,$templateID,$pid,$row);
   }

   function addExtensionStatics($idList,$templateID,$pid,$row) {
      global $TYPO3_LOADED_EXT;

      if ($row['static_file_mode']==1 || ($row['static_file_mode']==0 && substr($templateID,0,4)=='sys_' && $row['root'])) {
         reset($TYPO3_LOADED_EXT);
         while(list($extKey,$files)=each($TYPO3_LOADED_EXT))   {
            if (is_array($files) && ($files['ext_typoscript_constants.txt'] || $files['ext_typoscript_setup.txt'] || $files['ext_typoscript_editorcfg.txt']))  {
               $mExtKey = str_replace('_','',$extKey);
               $subrow=array(
                  'constants'=>  $files['ext_typoscript_constants.txt']?t3lib_div::getUrl($files['ext_typoscript_constants.txt']):'',
                  'config'=>     $files['ext_typoscript_setup.txt']?t3lib_div::getUrl($files['ext_typoscript_setup.txt']):'',
                  'editorcfg'=>     $files['ext_typoscript_editorcfg.txt']?t3lib_div::getUrl($files['ext_typoscript_editorcfg.txt']):'',
                  'title' =>     $extKey,
                  'uid' =>       $mExtKey
               );
               $subrow = $this->prependStaticExtra($subrow);

               $this->processTemplate($subrow,$idList.',ext_'.$mExtKey,$pid, 'ext_'.$mExtKey,$templateID);
            }
         }
      }
   }

   function prependStaticExtra($subrow)   {
      $subrow['config'].=$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup.'][$subrow['uid']];
      $subrow['editorcfg'].=$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_editorcfg.'][$subrow['uid']];
      $subrow['constants'].=$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants.'][$subrow['uid']];
      return $subrow;
   }

















   /*******************************************************************
    *
    * Parsing TypoScript code text from Template Records into PHP array
    *
    *******************************************************************/

   function generateConfig()  {
         // Add default TS for all three code types:
      array_unshift($this->constants,''.$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_constants']);  // Adding default TS/constants
      array_unshift($this->config,''.$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_setup']);   // Adding default TS/setup
      array_unshift($this->editorcfg,''.$GLOBALS['TYPO3_CONF_VARS']['FE']['defaultTypoScript_editorcfg']);  // Adding default TS/editorcfg

         // Parse the TypoScript code text for include-instructions!
      $this->procesIncludes();

         // These vars are also set lateron...
      $this->setup['resources']= $this->resources;
      $this->setup['sitetitle']= $this->sitetitle;



      // ****************************
      // Parse TypoScript Constants
      // ****************************

         // Initialize parser and match-condition classes:
      $constants = t3lib_div::makeInstance('t3lib_TSparser');
      $constants->breakPointLN=intval($this->ext_constants_BRP);
      $constants->setup = $this->const;
      $constants->setup = $this->mergeConstantsFromPageTSconfig($constants->setup);
      $matchObj = t3lib_div::makeInstance('t3lib_matchCondition');
      $matchObj->matchAlternative = $this->matchAlternative;
      $matchObj->matchAll = $this->matchAll;    // Matches ALL conditions in TypoScript

         // Traverse constants text fields and parse them
      foreach($this->constants as $str)   {
         $constants->parse($str,$matchObj);
      }

         // Read out parse errors if any
      $this->parserErrors['constants']=$constants->errors;

         // Then flatten the structure from a multi-dim array to a single dim array with all constants listed as key/value pairs (ready for substitution)
      $this->flatSetup = Array();
      $this->flattenSetup($constants->setup,'','');



      // ***********************************************
      // Parse TypoScript Setup (here called "config")
      // ***********************************************
         // Initialize parser and match-condition classes:
      $config = t3lib_div::makeInstance('t3lib_TSparser');
      $config->breakPointLN = intval($this->ext_config_BRP);
      $config->regLinenumbers = $this->ext_regLinenumbers;
      $config->setup = $this->setup;

         // Transfer information about conditions found in "Constants" and which of them returned true.
      $config->sections = $constants->sections;
      $config->sectionsMatch = $constants->sectionsMatch;

         // Traverse setup text fields and concatenate them into one, single string separated by a [GLOBAL] condition
      $all='';
      foreach($this->config as $str)   {
         $all.="\n[GLOBAL]\n".$str;
      }

         // Substitute constants in the Setup code:
      if ($this->tt_track) $GLOBALS['TT']->push('Substitute Constants ('.count($this->flatSetup).')');
      $all = $this->substituteConstants($all);
      if ($this->tt_track) $GLOBALS['TT']->pull();

         // Searching for possible unsubstituted constants left (only for information)
      if (strstr($all,'{$'))  {
         $findConst = explode('{$',$all);
         $theConstList=Array();
         next($findConst);
         while(list(,$constVal)=each($findConst))  {
            $constLen=t3lib_div::intInRange(strcspn($constVal,'}'),0,50);
            $theConstList[]='{$'.substr($constVal,0,$constLen+1);
         }
         if ($this->tt_track) $GLOBALS['TT']->setTSlogMessage(implode(',',$theConstList).': Constants may remain un-substituted!!',2);
      }

         // Logging the textual size of the TypoScript Setup field text with all constants substituted:
      if ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('TypoScript template size as textfile: '.strlen($all).' bytes');

         // Finally parse the Setup field TypoScript code (where constants are now substituted)
      $config->parse($all,$matchObj);

         // Read out parse errors if any
      $this->parserErrors['config']=$config->errors;

         // Transfer the TypoScript array from the parser object to the internal $this->setup array:
      $this->setup = $config->setup;
      if ($this->backend_info)   {
         $this->setup_constants = $constants->setup;     // Used for backend purposes only
      }




      // **************************************************
      // Parse Backend Editor Configuration (backend only)
      // **************************************************
      if ($this->parseEditorCfgField)  {
         $editorcfg = t3lib_div::makeInstance('t3lib_TSparser');
         $editorcfg->breakPointLN=intval($this->ext_editorcfg_BRP);
         $editorcfg->setup = array();  // Empty as a start...

         $all = implode("\n[GLOBAL]\n",$this->editorcfg);

            // substitute constants in config
         $all = $this->substituteConstants($all);

            // parse Config
         $matchObj->matchAll=1;  // This should make sure that conditions are disabled. For now they are NOT active for the backend.
         $editorcfg->parse($all,$matchObj);
         $this->parserErrors['editorcfg']=$editorcfg->errors;
         $this->setup_editorcfg = $editorcfg->setup;
      }





      // ****************************************************************
      // Final processing of the $this->setup TypoScript Template array
      // Basically: This is unsetting/setting of certain reserved keys.
      // ****************************************************************

         // These vars are allready set after 'processTemplate', but because $config->setup overrides them (in the line above!), we set them again. They are not changed compared to the value they had in the top of the page!
      unset($this->setup['resources']);
      unset($this->setup['resources.']);
      $this->setup['resources']= implode(',',t3lib_div::trimExplode(',',$this->resources,1));

      unset($this->setup['sitetitle']);
      unset($this->setup['sitetitle.']);
      $this->setup['sitetitle']= $this->sitetitle;

         // Unsetting some vars...
      unset($this->setup['types.']);
      unset($this->setup['types']);
      if (is_array($this->setup)) {
         reset ($this->setup);
         while(list($theKey,)=each($this->setup))  {
            if ($this->setup[$theKey]=='PAGE')  {
               $tN = $this->setup[$theKey.'.']['typeNum'];
               if (isset($tN))   {
                  $this->setup['types.'][$tN] = $theKey;
               }
            }
         }
      }
      unset($this->setup['styles.']);
      unset($this->setup['temp.']);
      unset($constants);

         // Storing the conditions found/matched information:
      $this->sections = $config->sections;
      $this->sectionsMatch = $config->sectionsMatch;
   }

   function procesIncludes()  {
      reset($this->constants);
      while(list($k)=each($this->constants)) {
         $this->constants[$k]=t3lib_TSparser::checkIncludeLines($this->constants[$k]);
      }

      reset($this->config);
      while(list($k)=each($this->config)) {
         $this->config[$k]=t3lib_TSparser::checkIncludeLines($this->config[$k]);
      }

      reset($this->editorcfg);
      while(list($k)=each($this->editorcfg)) {
         $this->editorcfg[$k]=t3lib_TSparser::checkIncludeLines($this->editorcfg[$k]);
      }
   }

   function mergeConstantsFromPageTSconfig($constArray)  {
      $TSdataArray = array();
      $TSdataArray[]=$GLOBALS['TYPO3_CONF_VARS']['BE']['defaultPageTSconfig'];   // Setting default configuration:

      for ($a=0;$a<=$this->outermostRootlineIndexWithTemplate;$a++)  {
         $TSdataArray[]=$this->absoluteRootLine[$a]['TSconfig'];
      }
         // Parsing the user TS (or getting from cache)
      $TSdataArray = t3lib_TSparser::checkIncludeLines_array($TSdataArray);
      $userTS = implode(chr(10).'[GLOBAL]'.chr(10),$TSdataArray);

      $parseObj = t3lib_div::makeInstance('t3lib_TSparser');
      $parseObj->parse($userTS);

      if (is_array($parseObj->setup['TSFE.']['constants.']))   {
         $constArray = t3lib_div::array_merge_recursive_overrule($constArray,$parseObj->setup['TSFE.']['constants.']);
      }
      return $constArray;
   }

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

   function substituteConstants($all)  {
      if ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('Constants to substitute: '.count($this->flatSetup));
      reset($this->flatSetup);
      while (list($const,$val)=each($this->flatSetup))   {
         if (!is_array($val)) {
            $all = str_replace('{$'.$const.'}',$val,$all);
         }
      }
      return $all;
   }











   /*******************************************************************
    *
    * Various API functions, used from elsewhere in the frontend classes
    *
    *******************************************************************/

   function splitConfArray($conf,$splitCount)   {

         // Initialize variables:
      $splitCount = intval($splitCount);
      $conf2 = Array();

      if ($splitCount && is_array($conf)) {

            // Initialize output to carry at least the keys:
         for ($aKey=0;$aKey<$splitCount;$aKey++)   {
            $conf2[$aKey] = array();
         }

            // Recursive processing of array keys:
         foreach($conf as $cKey => $val)  {
            if (is_array($val))  {
               $tempConf = $this->splitConfArray($val,$splitCount);
               foreach($tempConf as $aKey => $val) {
                  $conf2[$aKey][$cKey] = $val;
               }
            }
         }

            // Splitting of all values on this level of the TypoScript object tree:
         foreach($conf as $cKey => $val)  {
            if (!is_array($val)) {
               if (!strstr($val,'|*|') && !strstr($val,'||'))  {
                  for ($aKey=0;$aKey<$splitCount;$aKey++)   {
                     $conf2[$aKey][$cKey] = $val;
                  }
               } else {
                  $main = explode ('|*|',$val);
                  $mainCount = count($main);

                  $lastC = 0;
                  $middleC = 0;
                  $firstC = 0;

                  if ($main[0])  {
                     $first = explode('||',$main[0]);
                     $firstC = count($first);
                  }
                  if ($main[1])  {
                     $middle = explode('||',$main[1]);
                     $middleC = count($middle);
                  }
                  if ($main[2])  {
                     $last = explode('||',$main[2]);
                     $lastC = count($last);
                     $value = $last[0];
                  }

                  for ($aKey=0;$aKey<$splitCount;$aKey++)   {
                     if ($firstC && isset($first[$aKey])) {
                        $value = $first[$aKey];
                     } elseif ($middleC) {
                        $value = $middle[($aKey-$firstC)%$middleC];
                     }
                     if ($lastC && $lastC>=($splitCount-$aKey))   {
                        $value = $last[$lastC-($splitCount-$aKey)];
                     }
                     $conf2[$aKey][$cKey] = trim($value);
                  }
               }
            }
         }
      }
      return $conf2;
   }

   function getFileName($fileFromSetup)   {
      $file = trim($fileFromSetup);
      if (!$file) return;
         // cache
      $hash = md5($file);
      if (isset($this->fileCache[$hash])) {
         return $this->fileCache[$hash];
      }

      if (!strcmp(substr($file,0,4),'EXT:')) {
         $newFile='';
         list($extKey,$script)=explode('/',substr($file,4),2);
         if ($extKey && t3lib_extMgm::isLoaded($extKey)) {
            $extPath=t3lib_extMgm::extPath($extKey);
            $newFile=substr($extPath,strlen(PATH_site)).$script;
         }
         if (!@is_file(PATH_site.$newFile))  {
            if ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('Extension media file "'.$newFile.'" was not found!',3);
            return;
         } else $file=$newFile;
      }

         // find
      if (strstr($file,'/')) {   // here it is manual media
         if (@is_file($this->getFileName_backPath.$file))   {
            $outFile = $file;
            $fileInfo = t3lib_div::split_fileref($outFile);
            reset($this->allowedPaths);
            $OK=0;
            while(list(,$val)=each($this->allowedPaths)) {
               if (substr($fileInfo['path'],0,strlen($val))==$val){$OK=1; break;}
            }
            if ($OK) {
               $this->fileCache[$hash]=$outFile;
               return $outFile;
            } elseif ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('"'.$file.'" was not located in the allowed paths: ('.implode(',',$this->allowedPaths).')',3);
         } elseif ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('"'.$this->getFileName_backPath.$file.'" is not a file (non-uploads/.. resource, did not exist).',3);
      } else {    // Here it is uploaded media:
         $outFile = $this->extractFromResources($this->setup['resources'],$file);
         if ($outFile)  {
            if (@is_file($this->uplPath.$outFile)) {
               $this->fileCache[$hash] = $this->uplPath.$outFile;
               return $this->uplPath.$outFile;
            } elseif ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('"'.$this->uplPath.$outFile.'" is not a file (did not exist).',3);
         } elseif ($this->tt_track) $GLOBALS['TT']->setTSlogMessage('"'.$file.'" is not a file (uploads/.. resource).',3);
      }
   }

   function extractFromResources($res,$file) {
      if (t3lib_div::inList($res,$file))  {
         $outFile = $file;
      } elseif (strstr($file,'*')) {
         $fileparts=explode('*',$file);
         $c=count($fileparts);
         $files = explode(',',$res);
         while(list(,$val)=each($files))  {
            $test = trim($val);
            if (ereg('^'.quotemeta($fileparts[0]).'.*'.quotemeta($fileparts[$c-1]).'$', $test)) {
               $outFile = $test;
               break;
            }
         }
      }
      return $outFile;
   }

   function checkFile($name,$menuArr)  {
      reset ($menuArr);
      while (list($aKey,)=each($menuArr)) {
         $menuArr[$aKey][$name] = $this->getFileName($menuArr[$aKey][$name]);
      }
      return $menuArr;
   }

   function printTitle($title,$no_title=0,$titleFirst=0) {
      $st = trim($this->setup['sitetitle']) ? $this->setup['sitetitle']:'';
      $title = $no_title ? '' : $title;
      if ($titleFirst)  {
         $temp=$st;
         $st=$title;
         $title=$temp;
      }
      if ($title && $st)   {
         return $st.': '.$title;
      } else {
         return $st.$title;
      }
   }

   function fileContent($fName)  {
      $incFile = $this->getFileName($fName);
      if ($incFile && $fd=fopen($incFile,'rb')) {
         $content = '';
         while (!feof($fd))   {
            $content.=fread($fd, 5000);
         }
         fclose( $fd );
         return $content;
      }
   }

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

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

   function sortedKeyList($setupArr, $acceptOnlyProperties=FALSE) {
      $keyArr = Array();

      reset($setupArr);
      while(list($key,)=each($setupArr))  {
         $ikey = intval($key);
         if (!strcmp($ikey,$key) || $acceptOnlyProperties)  {
            $keyArr[] = $ikey;
         }
      }

      $keyArr = array_unique($keyArr);
      sort($keyArr);
      return $keyArr;
   }










   /*******************************************************************
    *
    * Functions for creating links
    *
    *******************************************************************/

   function linkData($page,$oTarget,$no_cache,$script,$overrideArray='',$addParams='',$typeOverride='')  {
      global $TYPO3_CONF_VARS;

      $LD = Array();

         // Overriding some fields in the page record and still preserves the values by adding them as parameters. Little strange function.
      if (is_array($overrideArray)) {
         foreach($overrideArray as $theKey => $theNewVal)   {
            $addParams.= '&real_'.$theKey.'='.rawurlencode($page[$theKey]);
            $page[$theKey] = $theNewVal;
         }
      }

         // Adding Mount Points, "&MP=", parameter for the current page if any is set:
      if (!strstr($addParams,'&MP='))  {
         if (trim($GLOBALS['TSFE']->MP_defaults[$page['uid']]))   {  // Looking for hardcoded defaults:
            $addParams.= '&MP='.rawurlencode(trim($GLOBALS['TSFE']->MP_defaults[$page['uid']]));
         } elseif ($GLOBALS['TSFE']->config['config']['MP_mapRootPoints']) {     // Else look in automatically created map:
            $m = $this->getFromMPmap($page['uid']);
            if ($m)  {
               $addParams.= '&MP='.rawurlencode($m);
            }
         }
      }

         // Setting ID/alias:
      if (!$script)  {$script = $GLOBALS['TSFE']->config['mainScript'];}
      if ($page['alias'])  {
         $LD['url'] = $script.'?id='.rawurlencode($page['alias']);
      } else {
         $LD['url'] = $script.'?id='.$page['uid'];
      }
         // Setting target
      $LD['target'] = trim($page['target']) ? trim($page['target']) : $oTarget;

         // typeNum
      $typeNum = $this->setup[$LD['target'].'.']['typeNum'];
      if (!$typeOverride && intval($GLOBALS['TSFE']->config['config']['forceTypeValue'])) {
         $typeOverride = intval($GLOBALS['TSFE']->config['config']['forceTypeValue']);
      }
      if (strcmp($typeOverride,'')) { $typeNum = $typeOverride; } // Override...
      if ($typeNum)  {
         $LD['type'] = '&type='.intval($typeNum);
      } else {
         $LD['type'] = '';
      }
      $LD['orig_type'] = $LD['type'];     // Preserving the type number. Will not be cleared if simulateStaticDocuments.

         // noCache
      $LD['no_cache'] = (trim($page['no_cache']) || $no_cache) ? '&no_cache=1' : '';

         // linkVars
      $LD['linkVars'] = $GLOBALS['TSFE']->linkVars.$addParams;

         // If simulateStaticDocuments is enabled:
      if ($GLOBALS['TSFE']->config['config']['simulateStaticDocuments'])   {
         $LD['type'] = '';
         $LD['url'] = '';

            // MD5/base64 method limitation:
         $remainLinkVars='';
         $flag_simulateStaticDocuments_pEnc = t3lib_div::inList('md5,base64',$GLOBALS['TSFE']->config['config']['simulateStaticDocuments_pEnc']) && !$LD['no_cache'];
         if ($flag_simulateStaticDocuments_pEnc)   {
            list($LD['linkVars'], $remainLinkVars) = $GLOBALS['TSFE']->simulateStaticDocuments_pEnc_onlyP_proc($LD['linkVars']);
         }

         $LD['url'].=$GLOBALS['TSFE']->makeSimulFileName(
                     $page['title'],
                     $page['alias'] ? $page['alias'] : $page['uid'],
                     intval($typeNum),
                     $LD['linkVars'],
                     $LD['no_cache']?1:0
                  );

         if ($flag_simulateStaticDocuments_pEnc)   {
            $LD['linkVars']=$remainLinkVars;
         }
         if ($GLOBALS['TSFE']->config['config']['simulateStaticDocuments']=='PATH_INFO')  {
            $LD['url'] = str_replace('.','/',$LD['url']);
            $LD['url'] = 'index.php/'.$LD['url'].'/?';
         } else {
            $LD['url'].= '.html?';
         }
      }

         // Add absRefPrefix if exists.
      $LD['url'] = $GLOBALS['TSFE']->absRefPrefix.$LD['url'];

         // If the special key 'sectionIndex_uid' (added 'manually' in tslib/menu.php to the page-record) is set, then the link jumps directly to a section on the page.
      $LD['sectionIndex'] = $page['sectionIndex_uid'] ? '#'.$page['sectionIndex_uid'] : '';

         // Compile the normal total url
      $LD['totalURL']= $this->removeQueryString($LD['url'].$LD['type'].$LD['no_cache'].$LD['linkVars'].$GLOBALS['TSFE']->getMethodUrlIdToken).$LD['sectionIndex'];

         // Call post processing function for link rendering:
      if (is_array($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['linkData-PostProc']))   {
         $_params = array(
                     'LD' => &$LD,
                     'args' => array('page'=>$page, 'oTarget'=>$oTarget, 'no_cache'=>$no_cache, 'script'=>$script, 'overrideArray'=>$overrideArray, 'addParams'=>$addParams, 'typeOverride'=>$typeOverride),
                     'typeNum' => $typeNum
                  );
         foreach($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_tstemplate.php']['linkData-PostProc'] as $_funcRef)  {
            t3lib_div::callUserFunction($_funcRef,$_params,$this);
         }
      }

         // Return the LD-array
      return $LD;
   }

   function getFromMPmap($pageId=0) {

         // Create map if not found already:
      if (!is_array($this->MPmap))  {
         $this->MPmap = array();

         $rootPoints = t3lib_div::trimExplode(',', strtolower($GLOBALS['TSFE']->config['config']['MP_mapRootPoints']),1);
         foreach($rootPoints as $p) {  // Traverse rootpoints:
            if ($p == 'root') {
               $p = $this->rootLine[0]['uid'];
               $initMParray = array();
               if ($this->rootLine[0]['_MOUNT_OL'] && $this->rootLine[0]['_MP_PARAM']) {
                  $initMParray[] = $this->rootLine[0]['_MP_PARAM'];
               }
            }
            $this->initMPmap_create($p,$initMParray);
         }
      }

         // Finding MP var for Page ID:
      if ($pageId)   {
         if (is_array($this->MPmap[$pageId]) && count($this->MPmap[$pageId])) {
            return implode(',',$this->MPmap[$pageId]);
         }
      }
   }

   function initMPmap_create($id,$MP_array=array(),$level=0)   {

      $id = intval($id);
      if($id<=0)  return;

         // First level, check id
      if (!$level)   {

            // Find mount point if any:
         $mount_info = $GLOBALS['TSFE']->sys_page->getMountPointInfo($id);

            // Overlay mode:
         if (is_array($mount_info) && $mount_info['overlay'])  {
            $MP_array[] = $mount_info['MPvar'];
            $id = $mount_info['mount_pid'];
         }

            // Set mapping information for this level:
         $this->MPmap[$id] = $MP_array;

            // Normal mode:
         if (is_array($mount_info) && !$mount_info['overlay']) {
            $MP_array[] = $mount_info['MPvar'];
            $id = $mount_info['mount_pid'];
         }
      }

      if ($id && $level<20)   {

         $nextLevelAcc = array();

            // Select and traverse current level pages:
         $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery(
                  'uid,pid,doktype,mount_pid,mount_pid_ol',
                  'pages',
                  'pid='.intval($id).' AND deleted=0 AND doktype!=255 AND doktype!=6'  // 255 = Garbage bin, 6 = Backend User Section
               );
         while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res))  {

               // Find mount point if any:
            $next_id = $row['uid'];
            $next_MP_array = $MP_array;
            $mount_info = $GLOBALS['TSFE']->sys_page->getMountPointInfo($next_id, $row);

               // Overlay mode:
            if (is_array($mount_info) && $mount_info['overlay'])  {
               $next_MP_array[] = $mount_info['MPvar'];
               $next_id = $mount_info['mount_pid'];
            }

            if (!isset($this->MPmap[$next_id])) {

                  // Set mapping information for this level:
               $this->MPmap[$next_id] = $next_MP_array;

                  // Normal mode:
               if (is_array($mount_info) && !$mount_info['overlay']) {
                  $next_MP_array[] = $mount_info['MPvar'];
                  $next_id = $mount_info['mount_pid'];
               }

                  // Register recursive call
                  // (have to do it this way since ALL of the current level should be registered BEFORE the sublevel at any time)
               $nextLevelAcc[] = array($next_id,$next_MP_array);
            }
         }

            // Call recursively, if any:
         foreach($nextLevelAcc as $pSet)  {
            $this->initMPmap_create($pSet[0],$pSet[1],$level+1);
         }
      }
   }
}


if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_tstemplate.php']) {
   include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_tstemplate.php']);
}
?>

---